mirror of
https://github.com/jstrdev/ps5directo.git
synced 2026-10-28 21:01:18 +01:00
6916 lines
291 KiB
Python
6916 lines
291 KiB
Python
"""PS5 Directo: transfiere archivos a la consola, los descomprime y los deja en su sitio.
|
|
|
|
Arranque: python app.py (o doble clic en "Iniciar PS5 Directo.bat")
|
|
"""
|
|
|
|
import ftplib
|
|
import json
|
|
import re
|
|
import os
|
|
import posixpath
|
|
import secrets
|
|
import socket
|
|
import sys
|
|
import threading
|
|
import time
|
|
import traceback
|
|
import urllib.parse
|
|
import urllib.request
|
|
import webbrowser
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
|
|
HERE = os.path.dirname(os.path.abspath(__file__))
|
|
sys.path.insert(0, HERE)
|
|
import engine as E # noqa: E402
|
|
import features as F # noqa: E402
|
|
|
|
VERSION = "1.21.0"
|
|
# Repositorio de GitHub donde se publican las versiones (usuario/nombre). Si lo rellenas,
|
|
# todas las copias buscan actualizaciones ahi sin tener que configurar nada.
|
|
DEFAULT_REPO = "jstrdev/ps5directo"
|
|
DATA_DIR = os.path.join(os.path.expanduser("~"), ".ps5directo")
|
|
SETTINGS_FILE = os.path.join(DATA_DIR, "settings.json")
|
|
JOBS_FILE = os.path.join(DATA_DIR, "jobs.json")
|
|
WORK_ROOT = "/data/ps5directo" # fuera de las rutas que escanea ShadowMountPlus
|
|
|
|
DEFAULTS = {
|
|
"ps5_ip": "",
|
|
"ftp_port": 2121,
|
|
"ftp_user": "anonymous",
|
|
"ftp_pass": "",
|
|
"bf_port": 5905,
|
|
"dest": "/data/homebrew",
|
|
"streams": 8,
|
|
"parallel_files": 2,
|
|
"limit_mbps": 0, # MB/s maximos hacia la PS5 (0 = sin limite)
|
|
"space_margin_gb": 25, # GB que siempre se dejan libres en la PS5
|
|
"update_repo": "", # "usuario/repositorio" de GitHub para buscar actualizaciones
|
|
"extract_threads": 0, # hilos de BFpilot al descomprimir (0 = automatico, max 8)
|
|
"extract_where": "ps5", # "ps5" = BFpilot en la consola; "pc" = 7-Zip en el PC sobre la marcha
|
|
"pc_temp_dir": "", # carpeta del PC donde bajar los RAR en modo "pc" (vacio = Descargas)
|
|
"sevenzip_path": "", # ruta de 7z.exe (vacio = buscarlo)
|
|
"chunk_mb": 4,
|
|
"buffer_mb": 256,
|
|
"retries": 8,
|
|
"passwords": [],
|
|
"guess_passwords": True,
|
|
"delete_archives": True,
|
|
"forge_auto_update": True, # bajar solo las versiones nuevas de PS5 Dump Forge (comprobando que valen)
|
|
"tour_done": False, # la guia de bienvenida ya se vio
|
|
"seen_version": "", # ultima version cuyas novedades ya se ensenaron
|
|
"shortcut_done": False, # ya se creo el acceso directo del escritorio una vez
|
|
"icon_ver": "", # version cuyo icono ya se dejo en la cache de la ventana
|
|
# 1.20
|
|
"elf_port": 9021, # cargador de payloads de la consola (etaHEN / elfldr)
|
|
"console_fw": "", # firmware de tu PS5 (p. ej. 13.60) para avisar de lo que no arrancara
|
|
"dup_check": True, # preguntar antes de enviar algo que ya esta en la consola
|
|
"verify_sums": True, # comprobar .sfv/.md5/.sha1 si vienen con las partes
|
|
"pc_format": "folder", # en el PC: folder, ffpkg, ffpfsc, lz4, lz4ffpkg (con PS5 Dump Forge)
|
|
"forge_path": "", # ruta de ps5-dump-forge.exe (vacio = descargarlo solo)
|
|
"keep_awake": True, # que el PC no se suspenda mientras hay envios
|
|
"welcome_seen": False, # la ventana de bienvenida ya se ha visto
|
|
"pc_collection": [], # carpetas del PC o del NAS con contenido para la consola (pestana Biblioteca > Tu PC)
|
|
"backup_dir": "", # copias de seguridad de la consola (vacio = Documentos\\PS5 Directo\\Copias)
|
|
"backup_auto": False, # una copia al dia, sola, si la consola esta encendida
|
|
"backup_keep": 10, # cuantas copias guardar
|
|
"backup_saves": True, "backup_config": True, "backup_appdb": True,
|
|
"lan_access": False, # abrir la app desde el movil (misma red)
|
|
"lan_port": 8780,
|
|
"lan_token": "",
|
|
"fmt_notice_seen": False, # ya se vio el aviso de que convertir ocupa sitio en el PC
|
|
}
|
|
|
|
LOCK = threading.RLock()
|
|
SETTINGS = dict(DEFAULTS)
|
|
JOBS = [] # lista de dicts (orden de cola)
|
|
CANCELS = {} # id -> threading.Event
|
|
WAKE = threading.Condition(LOCK)
|
|
EXTRACT_Q = [] # ids pendientes de extraer
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Persistencia
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _save_json(path, obj):
|
|
os.makedirs(DATA_DIR, exist_ok=True)
|
|
tmp = path + ".tmp"
|
|
with open(tmp, "w", encoding="utf-8") as f:
|
|
json.dump(obj, f, ensure_ascii=False, indent=1)
|
|
os.replace(tmp, path)
|
|
|
|
|
|
def load_state():
|
|
global JOBS
|
|
load_notifs()
|
|
try:
|
|
with open(SETTINGS_FILE, encoding="utf-8") as f:
|
|
SETTINGS.update(json.load(f))
|
|
except Exception:
|
|
pass
|
|
# 1.8.1: la 1.8.0 puso 1 hilo por error; volver a automatico una sola vez
|
|
if SETTINGS.get("_threads_v18") and not SETTINGS.get("_threads_v181"):
|
|
if int(SETTINGS.get("extract_threads") or 0) == 1:
|
|
SETTINGS["extract_threads"] = 0
|
|
SETTINGS["_threads_v181"] = True
|
|
try:
|
|
with open(JOBS_FILE, encoding="utf-8") as f:
|
|
JOBS = json.load(f)
|
|
except Exception:
|
|
JOBS = []
|
|
for j in JOBS:
|
|
if j["status"] not in ("hecho", "error", "cancelado", "pausado"):
|
|
j["status"] = "error"
|
|
j["error"] = "Se cerro el programa a medias. Pulsa Reintentar: continua donde se quedo."
|
|
sc = SETTINGS.get("sched") or {}
|
|
try:
|
|
if float(sc.get("start") or 0) > time.time():
|
|
SCHED["start"] = float(sc["start"])
|
|
if sc.get("after") in ("sleep", "shutdown"):
|
|
SCHED["after"] = sc["after"]
|
|
except (TypeError, ValueError):
|
|
pass
|
|
|
|
|
|
def save_jobs():
|
|
with LOCK:
|
|
_save_json(JOBS_FILE, JOBS)
|
|
|
|
|
|
def save_settings():
|
|
with LOCK:
|
|
_save_json(SETTINGS_FILE, SETTINGS)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Utilidades de trabajos
|
|
# ---------------------------------------------------------------------------
|
|
|
|
COMP_LEVELS = ("fast", "balanced", "smallest", "stored")
|
|
|
|
|
|
def new_job(lines, password, dest, title=None, where=None, raw=False, fmt=None, comp=None):
|
|
return {
|
|
"raw": bool(raw),
|
|
"fmt": fmt if fmt in F.FORGE_FORMATS else "",
|
|
"comp": comp if comp in COMP_LEVELS else "",
|
|
"where": where if where in ("ps5", "pc") else "",
|
|
"id": secrets.token_hex(4),
|
|
"created": time.time(),
|
|
"title": title or "",
|
|
"lines": lines,
|
|
"sources": [],
|
|
"password": password or "",
|
|
"dest": dest,
|
|
"status": "pendiente",
|
|
"phase": "En cola",
|
|
"sent": 0, "total": -1, "speed": 0.0,
|
|
"extract_pct": 0, "extract_text": "",
|
|
"error": "", "result": [], "log": [],
|
|
}
|
|
|
|
|
|
def find(job_id):
|
|
for j in JOBS:
|
|
if j["id"] == job_id:
|
|
return j
|
|
return None
|
|
|
|
|
|
def jlog(job, msg):
|
|
line = time.strftime("%H:%M:%S ") + msg
|
|
with LOCK:
|
|
job["log"].append(line)
|
|
del job["log"][:-300]
|
|
try:
|
|
print("[%s] %s" % (job["id"], msg))
|
|
except Exception: # consola de Windows sin UTF-8
|
|
print(("[%s] %s" % (job["id"], msg)).encode("ascii", "replace").decode())
|
|
|
|
|
|
def setj(job, **kw):
|
|
with LOCK:
|
|
job.update(kw)
|
|
|
|
|
|
def cfg_snapshot():
|
|
with LOCK:
|
|
return dict(SETTINGS)
|
|
|
|
|
|
def human(n):
|
|
n = float(n)
|
|
for u in ("B", "KB", "MB", "GB", "TB"):
|
|
if n < 1024 or u == "TB":
|
|
return "%.1f %s" % (n, u) if u != "B" else "%d B" % n
|
|
n /= 1024
|
|
|
|
|
|
class Meter:
|
|
"""Velocidad media de los ultimos segundos."""
|
|
|
|
def __init__(self):
|
|
self.lock = threading.Lock()
|
|
self.samples = []
|
|
self.total = 0
|
|
|
|
def __call__(self, n):
|
|
with self.lock:
|
|
self.total += n
|
|
now = time.time()
|
|
self.samples.append((now, self.total))
|
|
while self.samples and now - self.samples[0][0] > 6:
|
|
self.samples.pop(0)
|
|
|
|
def rate(self):
|
|
"""Media de los ultimos segundos. Si hay pocas muestras muy juntas (arranque,
|
|
reanudar), se divide al menos entre 2 s para no inventar velocidades absurdas."""
|
|
with self.lock:
|
|
now = time.time()
|
|
while self.samples and now - self.samples[0][0] > 6:
|
|
self.samples.pop(0)
|
|
if len(self.samples) < 2:
|
|
return 0.0
|
|
(t0, b0), (t1, b1) = self.samples[0], self.samples[-1]
|
|
if now - t1 > 3: # lleva rato sin llegar nada
|
|
return 0.0
|
|
return (b1 - b0) / max(2.0, t1 - t0)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Fase 1: comprobar enlaces y agrupar por conjunto de archivos
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _read_small(s, cancel, limit=4 * 1024 * 1024):
|
|
if s.size > limit:
|
|
raise E.PipeError("demasiado grande para ser un archivo de sumas")
|
|
buf = bytearray()
|
|
for data in s.stream(0, cfg_snapshot(), cancel, lambda n: None):
|
|
buf += data
|
|
if len(buf) > limit:
|
|
break
|
|
return bytes(buf).decode("utf-8", "replace")
|
|
|
|
|
|
def probe_job(job, cancel):
|
|
setj(job, status="comprobando", phase="Comprobando enlaces")
|
|
srcs = []
|
|
sums = dict(job.get("checks") or {})
|
|
for line in job["lines"]:
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
s = E.make_source(line)
|
|
jlog(job, "Comprobando: %s" % line[:120])
|
|
s.probe()
|
|
if s.kind != "folder" and F.is_checksum_name(s.name):
|
|
# .sfv / .md5 / .sha1: no se envian, sirven para comprobar las partes
|
|
try:
|
|
got = F.parse_checksums(_read_small(s, cancel), s.name)
|
|
sums.update(got)
|
|
jlog(job, " %s: sumas de comprobacion de %d archivo(s)" % (s.name, len(got)))
|
|
except Exception as e:
|
|
jlog(job, " No pude leer %s: %s" % (s.name, e))
|
|
continue
|
|
jlog(job, " %s (%s)%s" % (s.name, human(s.size) if s.size >= 0 else "tamano desconocido",
|
|
"" if s.ranges else " sin descarga en paralelo"))
|
|
srcs.append(s)
|
|
# partes que estan en el PC: si al lado hay un .sfv/.md5, tambien vale
|
|
seen_dirs = set()
|
|
for s in srcs:
|
|
if s.kind != "file":
|
|
continue
|
|
d = os.path.dirname(os.path.abspath(s.path))
|
|
if d in seen_dirs:
|
|
continue
|
|
seen_dirs.add(d)
|
|
try:
|
|
for n in os.listdir(d):
|
|
fp = os.path.join(d, n)
|
|
if F.is_checksum_name(n) and os.path.getsize(fp) < 4 * 1024 * 1024:
|
|
with open(fp, encoding="utf-8", errors="replace") as fh:
|
|
got = F.parse_checksums(fh.read(), n)
|
|
mine = {k: v for k, v in got.items() if k in {x.name.lower() for x in srcs}}
|
|
if mine:
|
|
sums.update(mine)
|
|
jlog(job, " %s: sumas de comprobacion de %d parte(s)" % (n, len(mine)))
|
|
except OSError:
|
|
pass
|
|
if not srcs:
|
|
raise E.PipeError("Solo hay archivos de sumas (.sfv/.md5): pega tambien las partes")
|
|
names = {s.name.lower() for s in srcs}
|
|
with LOCK:
|
|
job["checks"] = {k: v for k, v in sums.items() if k in names}
|
|
return srcs
|
|
|
|
|
|
def part_hasher(job, s):
|
|
"""StreamHasher para una parte si hay suma con la que compararla (y esta activado)."""
|
|
with LOCK:
|
|
on = SETTINGS.get("verify_sums", True)
|
|
chk = (job.get("checks") or {}).get(s.name.lower())
|
|
if not on or not chk:
|
|
return None
|
|
return F.StreamHasher(chk[0])
|
|
|
|
|
|
def verify_part(job, s, hasher, on_bad=None):
|
|
"""Compara la suma calculada al enviar con la del .sfv/.md5. Lanza PipeError si no coincide."""
|
|
if hasher is None:
|
|
return
|
|
algo, want = job["checks"][s.name.lower()]
|
|
if not hasher.valid or hasher.pos != s.size:
|
|
jlog(job, "%s: sin comprobar con %s (ya estaba enviado o se continuo de un envio anterior)"
|
|
% (s.name, algo.upper()))
|
|
return
|
|
got = hasher.hexdigest()
|
|
if got.lower() == want.lower():
|
|
jlog(job, "%s: %s correcto" % (s.name, algo.upper()))
|
|
return
|
|
if on_bad:
|
|
try:
|
|
on_bad()
|
|
except Exception:
|
|
pass
|
|
raise E.PipeError("La parte %s ha llegado dañada: su %s es %s y debería ser %s. Puede ser una descarga "
|
|
"corrupta o un .sfv/.md5 de otra versión. Pulsa Reintentar para volver a bajarla."
|
|
% (s.name, algo.upper(), got, want))
|
|
|
|
|
|
def split_into_sets(srcs):
|
|
groups = {}
|
|
order = []
|
|
for s in srcs:
|
|
k = E.set_key(s.name)
|
|
if k not in groups:
|
|
groups[k] = []
|
|
order.append(k)
|
|
groups[k].append(s)
|
|
return [sorted(groups[k], key=lambda s: E.volume_order(s.name)) for k in order]
|
|
|
|
|
|
def describe(srcs):
|
|
return [{"input": s.original, "name": s.name, "size": s.size, "kind": s.kind} for s in srcs]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Fase 2: enviar a la PS5
|
|
# ---------------------------------------------------------------------------
|
|
|
|
GiB = 1024 ** 3
|
|
RUNAWAY_SLACK = int(os.environ.get("PS5D_RUNAWAY_SLACK", 2 * 1024 ** 3))
|
|
|
|
|
|
def free_space(bf):
|
|
"""Bytes libres en /data segun BFpilot, o None si no responde."""
|
|
try:
|
|
st = bf._req("GET", "/api/fs/stat", {"path": "/data"})
|
|
v = st.get("availableBytes")
|
|
return int(v) if v is not None else None
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def margin_bytes():
|
|
with LOCK:
|
|
return max(0, int(SETTINGS.get("space_margin_gb", 25) or 0)) * GiB
|
|
|
|
|
|
def start_space_watch(job, bf, cancel, what):
|
|
"""Vigila el espacio libre mientras se envia o descomprime. Si baja del margen,
|
|
lo para todo antes de que la PS5 se quede sin sitio. Devuelve un Event para pararlo."""
|
|
done = threading.Event()
|
|
margin = margin_bytes()
|
|
if margin <= 0:
|
|
return done
|
|
|
|
def loop():
|
|
low_logged = False
|
|
while not done.wait(15):
|
|
free = free_space(bf)
|
|
if free is None:
|
|
continue
|
|
if free < margin:
|
|
with LOCK:
|
|
left = max(0, int(job.get("total") or 0) - int(job.get("sent") or 0))
|
|
job["need_bytes"] = int(max(0, left + margin - free)) or int(margin - free)
|
|
job["_stop"] = ("Parado para no llenar la PS5 (%s): quedan %s libres y el margen "
|
|
"es %s. Libera espacio y pulsa Reintentar; sigue donde iba."
|
|
% (what, human(free), human(margin)))
|
|
jlog(job, "ESPACIO: quedan %s libres (< %s). Paro %s." % (human(free), human(margin), what))
|
|
cancel.set()
|
|
return
|
|
if free < margin * 2 and not low_logged:
|
|
jlog(job, "Aviso: queda poco espacio en la PS5 (%s libres)" % human(free))
|
|
low_logged = True
|
|
|
|
threading.Thread(target=loop, daemon=True).start()
|
|
return done
|
|
|
|
|
|
def adopt_previous(job, bf, inc, names):
|
|
"""Mueve a 'inc' las partes que otros trabajos ya mandaron (completas o a medias)."""
|
|
root = WORK_ROOT + "/incoming"
|
|
try:
|
|
dirs = [e["name"] for e in bf.listdir(root) if e.get("dir")]
|
|
except Exception:
|
|
return
|
|
try:
|
|
bf.mkdir(inc)
|
|
except Exception:
|
|
pass
|
|
want = set(names) | {n + ".ps5part" for n in names}
|
|
for d in dirs:
|
|
path = "%s/%s" % (root, d)
|
|
if path == inc:
|
|
continue
|
|
try:
|
|
entries = bf.listdir(path)
|
|
except Exception:
|
|
continue
|
|
for e in entries:
|
|
if e["name"] in want and not bf.exists("%s/%s" % (inc, e["name"])):
|
|
try:
|
|
bf.rename("%s/%s" % (path, e["name"]), "%s/%s" % (inc, e["name"]))
|
|
jlog(job, "Aprovecho lo ya enviado: %s" % e["name"])
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def send_parts_parallel(job, cfg, srcs, inc, cancel, meter, set_sent):
|
|
"""Envia las partes de un comprimido, varias a la vez (cada una por su propia
|
|
conexion FTP). En Wi-Fi, dos conexiones suman mas que una sola."""
|
|
n = max(1, min(int(cfg.get("parallel_files", 2)), 4, len(srcs)))
|
|
if n > 1:
|
|
cfg = dict(cfg)
|
|
cfg["buffer_mb"] = max(64, int(cfg.get("buffer_mb", 256)) // n)
|
|
stop = threading.Event() # se activa si cancelas o si una parte falla
|
|
done = {} # parte -> bytes enviados
|
|
errors = []
|
|
lock = threading.Lock()
|
|
pending = list(srcs)
|
|
|
|
def relay_cancel():
|
|
while not stop.is_set():
|
|
if cancel.wait(0.5):
|
|
stop.set()
|
|
|
|
def progress(name, v):
|
|
with lock:
|
|
done[name] = v
|
|
total = sum(done.values())
|
|
set_sent(total)
|
|
|
|
def phase():
|
|
with lock:
|
|
active = [s.name for s in srcs if 0 < done.get(s.name, 0) < max(1, s.size)]
|
|
if active:
|
|
setj(job, phase="Enviando " + " + ".join(active))
|
|
|
|
def runner():
|
|
while not stop.is_set():
|
|
with lock:
|
|
if not pending:
|
|
return
|
|
s = pending.pop(0)
|
|
done.setdefault(s.name, 0)
|
|
try:
|
|
hasher = part_hasher(job, s)
|
|
remote = "%s/%s" % (inc, s.name)
|
|
|
|
def make(off, s=s, hasher=hasher):
|
|
it = s.stream(off, cfg, stop, meter)
|
|
return hasher.wrap(it, off) if hasher else it
|
|
E.upload(cfg, remote, s.size, make,
|
|
lambda v, s=s: (progress(s.name, v), phase()),
|
|
stop, lambda msg: jlog(job, msg))
|
|
verify_part(job, s, hasher,
|
|
on_bad=lambda remote=remote: E.Ftp(cfg).call(lambda f: f.delete(remote)))
|
|
progress(s.name, max(0, s.size))
|
|
except Exception as e:
|
|
with lock:
|
|
errors.append(e)
|
|
stop.set()
|
|
return
|
|
|
|
threading.Thread(target=relay_cancel, daemon=True).start()
|
|
if n > 1:
|
|
jlog(job, "Enviando %d partes a la vez" % n)
|
|
threads = [threading.Thread(target=runner, daemon=True) for _ in range(n)]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
stop.set()
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
real = [e for e in errors if not isinstance(e, E.Cancelled)]
|
|
if real:
|
|
raise real[0]
|
|
if errors:
|
|
raise errors[0]
|
|
|
|
|
|
def live_limit_bps():
|
|
with LOCK:
|
|
return float(SETTINGS.get("limit_mbps", 0) or 0) * 1024 * 1024
|
|
|
|
|
|
def transfer_job(job, srcs, cancel):
|
|
cfg = cfg_snapshot()
|
|
cfg["_log"] = lambda m: jlog(job, m)
|
|
cfg["_limit_bps"] = live_limit_bps
|
|
if job.get("raw"):
|
|
return raw_job(job, srcs, cancel)
|
|
if srcs[0].kind == "folder":
|
|
if job.get("fmt") == "plain" and os.path.isfile(os.path.join(srcs[0].path, "ampr_assets.index")):
|
|
with LOCK:
|
|
job["_plain_conv"] = True # carpeta empaquetada en LZ4 -> carpeta normal
|
|
return folder_job(job, srcs[0], cancel)
|
|
names = [s.name for s in srcs]
|
|
archives = [s for s in srcs if E.is_archive(s.name)]
|
|
with LOCK:
|
|
if job.get("fmt") == "plain" and len(srcs) == 1 and (
|
|
srcs[0].name.lower().endswith(CONV_SRC_EXTS) or (archives and LZ4_NAME_RE.search(srcs[0].name))):
|
|
job["_plain_conv"] = True # imagen, .fpkg o LZ4 -> carpeta normal con Forge
|
|
fmt = job_fmt(job)
|
|
if fmt and len(srcs) == 1 and srcs[0].name.lower().endswith(CONV_SRC_EXTS):
|
|
want = F.FORGE_FORMATS[fmt][1]
|
|
if want and srcs[0].name.lower().endswith(want) and fmt != "lz4ffpkg":
|
|
jlog(job, "Ya viene como %s: lo envío tal cual, sin convertir" % want)
|
|
else:
|
|
return pc_extract_job(job, srcs, cancel)
|
|
if archives and (job_where(job) == "pc" or fmt or any(E.is_tar(a.name) for a in archives)):
|
|
return pc_extract_job(job, srcs, cancel)
|
|
m = E.SPLIT_RAW_RE.match(srcs[0].name)
|
|
raw_split = (not archives and len(srcs) >= 1 and m
|
|
and all(E.SPLIT_RAW_RE.match(s.name) for s in srcs))
|
|
known = all(s.size >= 0 for s in srcs)
|
|
total = sum(s.size for s in srcs) if known else -1
|
|
# Carpeta por conjunto de archivos (no por trabajo): si mandas luego las partes que faltaban
|
|
# en otro trabajo, aprovecha lo que ya estaba en la consola.
|
|
inc = "%s/incoming/%s" % (WORK_ROOT, E.safe_name(E.set_key(srcs[0].name)) or job["id"])
|
|
meter = Meter() # descarga (lo que entra al PC)
|
|
up = Meter() # envio a la PS5 (lo que importa)
|
|
stop_speed = threading.Event()
|
|
last_sent = {"v": None}
|
|
sent_lock = threading.Lock()
|
|
|
|
def set_sent(v):
|
|
# Varias partes avisan a la vez y los avisos pueden llegar desordenados:
|
|
# solo cuenta lo que supera el maximo ya visto (nunca dos veces lo mismo).
|
|
with sent_lock:
|
|
prev = last_sent["v"]
|
|
if prev is not None and v <= prev:
|
|
return
|
|
if prev is not None and v - prev < 64 * 1024 * 1024:
|
|
up(v - prev)
|
|
last_sent["v"] = v
|
|
setj(job, sent=v)
|
|
|
|
def speed_loop():
|
|
while not stop_speed.wait(1):
|
|
setj(job, speed=up.rate(), dl_speed=meter.rate())
|
|
|
|
threading.Thread(target=speed_loop, daemon=True).start()
|
|
setj(job, status="enviando", total=total, sent=0)
|
|
bf = E.BFpilot(cfg)
|
|
|
|
adopt_previous(job, bf, inc, [s.name for s in srcs])
|
|
check_duplicates_first(job, bf, E.title_id(srcs[0].name))
|
|
|
|
# Comprobacion de espacio: lo que falta por enviar + margen. La descompresion la
|
|
# vuelve a comprobar BFpilot antes de empezar (sabe lo que ocupa de verdad).
|
|
free = free_space(bf)
|
|
if free is not None and total > 0:
|
|
present = 0
|
|
try:
|
|
want = {s.name: s.size for s in srcs}
|
|
for e in bf.listdir(inc):
|
|
n = e.get("name", "")
|
|
base = n[:-8] if n.endswith(".ps5part") else n
|
|
if base in want:
|
|
present += min(int(e.get("size") or 0), max(0, want[base]))
|
|
except Exception:
|
|
pass
|
|
remaining = max(0, total - present)
|
|
margin = margin_bytes()
|
|
if remaining + margin > free:
|
|
stop_speed.set()
|
|
raise no_space(job, remaining, free,
|
|
"No hay sitio en la PS5: faltan por enviar %s, hay %s libres y dejo %s "
|
|
"de margen (Ajustes). Libera espacio y pulsa Reintentar."
|
|
% (human(remaining), human(free), human(margin)))
|
|
if archives:
|
|
est = int(total * 5)
|
|
if free - remaining - est < margin:
|
|
jlog(job, "Ojo: el contenido descomprimido puede ocupar hasta ~5 veces el RAR (~%s) y no se "
|
|
"si cabra. Si al descomprimir baja del margen, lo paro y los RAR se quedan "
|
|
"en la PS5." % human(est))
|
|
jlog(job, "Espacio libre en la PS5: %s" % human(free))
|
|
watch = start_space_watch(job, bf, cancel, "el envio")
|
|
done_before = 0
|
|
try:
|
|
if archives or len(srcs) > 1 and not raw_split:
|
|
# Volumenes de un archivo comprimido: cada uno a su sitio, separados
|
|
send_parts_parallel(job, cfg, srcs, inc, cancel, meter, set_sent)
|
|
return {"mode": "archive", "dir": inc, "first": E.first_volume(names)}
|
|
if raw_split:
|
|
# .001 .002 ... -> se unen en un solo archivo mientras se envian
|
|
base_name = E.SPLIT_RAW_RE.match(srcs[0].name).group("base")
|
|
if not known:
|
|
raise E.PipeError("Para unir partes hace falta saber el tamano de cada una")
|
|
remote = "%s/%s" % (inc, base_name)
|
|
setj(job, phase="Enviando y uniendo %d partes en %s" % (len(srcs), base_name))
|
|
jlog(job, "Uniendo %d partes en %s" % (len(srcs), base_name))
|
|
E.upload(cfg, remote, total,
|
|
lambda off: E.concat_stream(srcs, off, cfg, cancel, meter),
|
|
lambda n: set_sent(n), cancel, lambda msg: jlog(job, msg))
|
|
if E.is_archive(base_name):
|
|
return {"mode": "archive", "dir": inc, "first": base_name}
|
|
return {"mode": "file", "path": remote, "name": base_name}
|
|
s = srcs[0]
|
|
remote = "%s/%s" % (inc, s.name)
|
|
setj(job, phase="Enviando %s" % s.name)
|
|
hasher = part_hasher(job, s)
|
|
|
|
def make(off):
|
|
it = s.stream(off, cfg, cancel, meter)
|
|
return hasher.wrap(it, off) if hasher else it
|
|
E.upload(cfg, remote, s.size, make,
|
|
lambda n: set_sent(n), cancel, lambda msg: jlog(job, msg))
|
|
verify_part(job, s, hasher, on_bad=lambda: E.Ftp(cfg).call(lambda f: f.delete(remote)))
|
|
return {"mode": "file", "path": remote, "name": s.name}
|
|
finally:
|
|
stop_speed.set()
|
|
watch.set()
|
|
setj(job, speed=0.0, dl_speed=0.0)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Envio "tal cual" (desde el explorador de la consola): sin descomprimir ni colocar
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def raw_job(job, srcs, cancel):
|
|
cfg = cfg_snapshot()
|
|
cfg["_limit_bps"] = live_limit_bps
|
|
dest = (job.get("dest") or cfg["dest"]).rstrip("/") or "/"
|
|
total = sum(max(0, s.size) for s in srcs)
|
|
up, meter = Meter(), Meter()
|
|
state = {"base": 0, "last": 0}
|
|
stop_speed = threading.Event()
|
|
|
|
def speed_loop():
|
|
while not stop_speed.wait(1):
|
|
setj(job, speed=up.rate(), dl_speed=meter.rate())
|
|
threading.Thread(target=speed_loop, daemon=True).start()
|
|
|
|
def prog(v):
|
|
cur = state["base"] + v
|
|
if cur > state["last"]:
|
|
up(cur - state["last"])
|
|
state["last"] = cur
|
|
setj(job, sent=cur)
|
|
setj(job, status="enviando", total=total if total > 0 else -1, sent=0)
|
|
placed = []
|
|
try:
|
|
for s in srcs:
|
|
target = dest + "/" + s.name
|
|
if s.kind == "folder":
|
|
setj(job, phase="Enviando carpeta: %s" % s.name)
|
|
sent, skipped, resumed = E.upload_tree(cfg, s, target, cancel, lambda m: jlog(job, m),
|
|
lambda v, rel: prog(v))
|
|
jlog(job, "Carpeta enviada: %d archivos nuevos, %d ya estaban iguales, %d continuados"
|
|
% (sent, skipped, resumed))
|
|
else:
|
|
setj(job, phase="Enviando %s" % s.name)
|
|
E.upload(cfg, target, s.size, lambda off, s=s: s.stream(off, cfg, cancel, meter),
|
|
prog, cancel, lambda m: jlog(job, m))
|
|
state["base"] += max(0, s.size)
|
|
placed.append(target)
|
|
finally:
|
|
stop_speed.set()
|
|
setj(job, speed=0.0, dl_speed=0.0)
|
|
return {"mode": "done", "placed": placed, "game": False}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Historial (pestana Actividad)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
HISTORY_FILE = os.path.join(DATA_DIR, "history.json")
|
|
HISTORY_LOCK = threading.Lock()
|
|
|
|
|
|
def record_history(job):
|
|
try:
|
|
with HISTORY_LOCK:
|
|
try:
|
|
with open(HISTORY_FILE, encoding="utf-8") as f:
|
|
hist = json.load(f)
|
|
except Exception:
|
|
hist = []
|
|
hist.append({
|
|
"t": time.time(), "id": job["id"], "title": job.get("title") or "",
|
|
"status": job.get("status"), "size": job.get("total", -1),
|
|
"result": job.get("result") or [], "error": job.get("error") or "",
|
|
"secs": int(time.time() - float(job.get("started") or job.get("created") or time.time())),
|
|
"where": "raw" if job.get("raw") else ("pc" if (job.get("info") or {}).get("mode") == "pcx" else "ps5"),
|
|
"dest": job.get("dest") or "",
|
|
# para "Descargar de nuevo" desde el historial
|
|
"redo": {"lines": list(job.get("orig_lines") or job.get("lines") or []), "where": job.get("where") or "",
|
|
"raw": bool(job.get("raw")), "fmt": job.get("fmt") or "", "comp": job.get("comp") or "",
|
|
"fmt_set": bool(job.get("fmt_set"))},
|
|
})
|
|
_save_json(HISTORY_FILE, hist[-500:])
|
|
if job.get("status") == "hecho":
|
|
torrent_cleanup(job)
|
|
title = job.get("title") or "Transferencia"
|
|
link = {"tab": "Transfers", "job": job["id"]}
|
|
if job.get("status") == "hecho":
|
|
notify("ok", "Terminado: %s" % title, ", ".join(job.get("result") or [])[:300], link)
|
|
elif job.get("status") == "error":
|
|
notify("err", "Error: %s" % title, job.get("error") or "", link)
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
|
|
NOTIF_FILE = os.path.join(DATA_DIR, "notifications.json")
|
|
NOTIF_LOCK = threading.Lock()
|
|
NOTIFS = [] # lo mas nuevo primero
|
|
|
|
|
|
def load_notifs():
|
|
try:
|
|
with open(NOTIF_FILE, encoding="utf-8") as f:
|
|
NOTIFS[:] = json.load(f)[:100]
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def save_notifs():
|
|
with NOTIF_LOCK:
|
|
data = list(NOTIFS)
|
|
try:
|
|
_save_json(NOTIF_FILE, data)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def notify(level, title, body="", link=None, key=None):
|
|
"""Aviso para la campana. level: ok, info, warn, err. key evita repetir el mismo aviso."""
|
|
with NOTIF_LOCK:
|
|
if key and any(n.get("key") == key for n in NOTIFS):
|
|
return
|
|
NOTIFS.insert(0, {"id": secrets.token_hex(4), "t": time.time(), "level": level, "title": title,
|
|
"body": (body or "")[:600], "link": link, "key": key, "read": False})
|
|
del NOTIFS[100:]
|
|
save_notifs()
|
|
|
|
|
|
def read_history():
|
|
try:
|
|
with open(HISTORY_FILE, encoding="utf-8") as f:
|
|
return list(reversed(json.load(f)))
|
|
except Exception:
|
|
return []
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Explorador de archivos de la consola
|
|
# ---------------------------------------------------------------------------
|
|
|
|
FMOP = {"busy": False, "op": "", "current": "", "items_done": 0, "items_total": 0,
|
|
"bytes_done": 0, "bytes_total": 0, "error": "", "message": "", "t0": 0.0, "local": ""}
|
|
FM_CANCEL = threading.Event()
|
|
|
|
|
|
def fm_clean(path):
|
|
path = "/" + "/".join(x for x in str(path or "/").replace("\\", "/").split("/") if x and x != ".")
|
|
if ".." in path.split("/"):
|
|
raise E.PipeError("Ruta no valida")
|
|
return path
|
|
|
|
|
|
def fm_list(path):
|
|
cfg = cfg_snapshot()
|
|
path = fm_clean(path)
|
|
bf = E.BFpilot(cfg)
|
|
out = {"path": path, "entries": [], "free": None, "total": None, "via": "bfpilot"}
|
|
if bf.alive():
|
|
ents = bf.listdir(path)
|
|
out["entries"] = [{"name": e.get("name"), "dir": bool(e.get("dir")), "size": e.get("size"),
|
|
"mtime": e.get("mtime"), "mode": e.get("mode")} for e in ents]
|
|
try:
|
|
st = bf._req("GET", "/api/fs/stat", {"path": path})
|
|
out["free"] = st.get("availableBytes")
|
|
out["total"] = st.get("usableTotalBytes") or st.get("totalBytes")
|
|
except Exception:
|
|
pass
|
|
else:
|
|
out["via"] = "ftp"
|
|
f = E.Ftp(cfg).connect()
|
|
try:
|
|
for name, x in E.ftp_listdir(f, path):
|
|
out["entries"].append({"name": name, "dir": x["type"] == "dir", "size": x["size"],
|
|
"mtime": x["mtime"], "mode": x["mode"]})
|
|
finally:
|
|
try:
|
|
f.quit()
|
|
except Exception:
|
|
pass
|
|
out["entries"].sort(key=lambda e: (not e["dir"], (e["name"] or "").lower()))
|
|
return out
|
|
|
|
|
|
def fm_bf():
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
if not bf.alive():
|
|
raise E.PipeError("BFpilot no responde: cargalo para copiar, mover, borrar o calcular tamanos")
|
|
return bf
|
|
|
|
|
|
def fm_bf_opt():
|
|
"""BFpilot si esta cargado, o None (entonces se hace por FTP)."""
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
return bf if bf.alive() else None
|
|
|
|
|
|
# ---- lo mismo por FTP, para cuando BFpilot no esta cargado -------------------
|
|
|
|
def _ftp_entries(f, path):
|
|
"""[(nombre, es_carpeta, tamano)] de una carpeta remota."""
|
|
return [(n, x["type"] == "dir", x["size"]) for n, x in E.ftp_listdir(f, path)]
|
|
|
|
|
|
def _ftp_kind(f, path):
|
|
"""'dir', 'file' o None."""
|
|
parent, name = posixpath.dirname(path) or "/", posixpath.basename(path)
|
|
try:
|
|
for n, d, _ in _ftp_entries(f, parent):
|
|
if n == name:
|
|
return "dir" if d else "file"
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
|
|
def _ftp_walk(f, root, cancel=None):
|
|
"""(archivos [(ruta, rel, tamano)], carpetas [rel]) de una carpeta, de arriba abajo."""
|
|
files, dirs = [], []
|
|
stack = [""]
|
|
while stack:
|
|
if cancel is not None and cancel.is_set():
|
|
raise E.Cancelled()
|
|
rel = stack.pop()
|
|
cur = root + ("/" + rel if rel else "")
|
|
for n, d, sz in _ftp_entries(f, cur):
|
|
r = (rel + "/" + n).lstrip("/")
|
|
if d:
|
|
dirs.append(r)
|
|
stack.append(r)
|
|
else:
|
|
files.append((cur + "/" + n, r, sz))
|
|
return files, dirs
|
|
|
|
|
|
def ftp_du(cfg, path):
|
|
def go(f):
|
|
k = _ftp_kind(f, path)
|
|
if k == "file":
|
|
return int(f.size(path) or 0)
|
|
files, _ = _ftp_walk(f, path)
|
|
return sum(sz for _, _, sz in files)
|
|
return E.Ftp(cfg).call(go)
|
|
|
|
|
|
def ftp_rmtree(cfg, path, cancel, on_item=None):
|
|
def go(f):
|
|
k = _ftp_kind(f, path)
|
|
if k is None:
|
|
return
|
|
if k == "file":
|
|
f.delete(path)
|
|
return
|
|
files, dirs = _ftp_walk(f, path, cancel)
|
|
for i, (rp, _, _) in enumerate(files):
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
if on_item:
|
|
on_item(rp, i, len(files))
|
|
f.delete(rp)
|
|
for d in sorted(dirs, key=lambda x: -x.count("/")):
|
|
f.rmd(path + "/" + d)
|
|
f.rmd(path)
|
|
E.Ftp(cfg).call(go)
|
|
|
|
|
|
def ftp_chmod_tree(cfg, path, cancel):
|
|
def go(f):
|
|
n = 1
|
|
f.sendcmd("SITE CHMOD 777 " + path)
|
|
if _ftp_kind(f, path) == "dir":
|
|
files, dirs = _ftp_walk(f, path, cancel)
|
|
for d in dirs:
|
|
f.sendcmd("SITE CHMOD 777 %s/%s" % (path, d))
|
|
for rp, _, _ in files:
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
f.sendcmd("SITE CHMOD 777 " + rp)
|
|
n += len(files) + len(dirs)
|
|
return n
|
|
return E.Ftp(cfg).call(go)
|
|
|
|
|
|
def ftp_relay_copy(cfg, src, target, cancel, progress):
|
|
"""Copia dentro de la consola pasando por el PC (sin BFpilot): lee por una conexion FTP
|
|
y escribe por otra. progress(bytes_hechos, bytes_totales, ruta_actual)."""
|
|
a = E.Ftp(cfg).connect()
|
|
b = E.Ftp(cfg).connect()
|
|
try:
|
|
k = _ftp_kind(a, src)
|
|
if k is None:
|
|
raise E.PipeError("No existe %s" % src)
|
|
if k == "file":
|
|
files, dirs = [(src, "", int(a.size(src) or 0))], []
|
|
else:
|
|
files, dirs = _ftp_walk(a, src, cancel)
|
|
E.Ftp.mkdirs(b, target)
|
|
for d in dirs:
|
|
E.Ftp.mkdirs(b, target + "/" + d)
|
|
total = sum(sz for _, _, sz in files)
|
|
done = 0
|
|
for rp, rel, sz in files:
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
dst = target + ("/" + rel if rel else "")
|
|
E.Ftp.mkdirs(b, posixpath.dirname(dst))
|
|
cr = a.transfercmd("RETR " + rp)
|
|
cw = b.transfercmd("STOR " + dst)
|
|
try:
|
|
while True:
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
chunk = cr.recv(E.MiB)
|
|
if not chunk:
|
|
break
|
|
cw.sendall(chunk)
|
|
done += len(chunk)
|
|
progress(done, total, rp)
|
|
finally:
|
|
cr.close()
|
|
cw.close()
|
|
a.voidresp()
|
|
b.voidresp()
|
|
got = E.Ftp.size(b, dst)
|
|
if got is not None and got != sz:
|
|
raise E.PipeError("La copia de %s salio incompleta (%s de %s)" % (rp, got, sz))
|
|
finally:
|
|
for f in (a, b):
|
|
try:
|
|
f.quit()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
# ---- operaciones largas con progreso -----------------------------------------
|
|
|
|
OP_DONE = {"copy": "Copiado", "move": "Movido", "delete": "Borrado", "download": "Descargado al PC",
|
|
"chmod": "Permisos puestos", "extract": "Extraído"}
|
|
OP_FAIL = {"copy": "Error al copiar", "move": "Error al mover", "delete": "Error al borrar",
|
|
"download": "Error al descargar", "chmod": "Error al poner permisos", "extract": "Error al extraer"}
|
|
|
|
|
|
def _fm_start(op, items_total, fn, where=None, names=None):
|
|
with LOCK:
|
|
if FMOP["busy"]:
|
|
raise E.PipeError("Ya hay una operacion en marcha en el explorador")
|
|
FMOP.update(busy=True, op=op, current="", items_done=0, items_total=items_total, bytes_done=0,
|
|
bytes_total=0, error="", message="", t0=time.time(), local="")
|
|
FM_CANCEL.clear()
|
|
what = ", ".join((names or [])[:3]) + ("…" if names and len(names) > 3 else "")
|
|
link = {"tab": "Files", "path": where} if where else None
|
|
|
|
def run():
|
|
try:
|
|
fn()
|
|
with LOCK:
|
|
if not FMOP["message"]:
|
|
FMOP["message"] = "Hecho"
|
|
msg = FMOP["message"]
|
|
if time.time() - FMOP["t0"] > 8 or op in ("extract",):
|
|
notify("ok", "%s: %s" % (OP_DONE.get(op, op), what) if what else OP_DONE.get(op, op),
|
|
msg if msg != "Hecho" else "", link)
|
|
except E.Cancelled:
|
|
with LOCK:
|
|
FMOP["error"] = "Cancelado"
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
with LOCK:
|
|
FMOP["error"] = str(e)
|
|
notify("err", "%s: %s" % (OP_FAIL.get(op, op), what) if what else OP_FAIL.get(op, op),
|
|
str(e), link)
|
|
finally:
|
|
with LOCK:
|
|
FMOP["busy"] = False
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
|
|
def _names_in(path):
|
|
try:
|
|
return {e["name"]: e["dir"] for e in fm_list(path)["entries"]}
|
|
except Exception:
|
|
return {}
|
|
|
|
|
|
def _free_name(name, taken):
|
|
"""'juego' -> 'juego (2)'; 'a.zip' -> 'a (2).zip'."""
|
|
base, ext = name, ""
|
|
m = re.match(r"^(.*?)(\.[A-Za-z0-9]{1,5})$", name)
|
|
if m and m.group(1):
|
|
base, ext = m.group(1), m.group(2)
|
|
k = 2
|
|
while "%s (%d)%s" % (base, k, ext) in taken:
|
|
k += 1
|
|
return "%s (%d)%s" % (base, k, ext)
|
|
|
|
|
|
def fm_conflicts(srcs, dst):
|
|
dst = fm_clean(dst)
|
|
have = _names_in(dst)
|
|
out = []
|
|
for s in srcs:
|
|
s = fm_clean(s)
|
|
n = posixpath.basename(s)
|
|
if n in have:
|
|
out.append({"name": n, "dir": have[n], "same": posixpath.dirname(s) == dst})
|
|
return out
|
|
|
|
|
|
def fm_paste(op, srcs, dst, mode="replace"):
|
|
"""mode: replace (reemplaza archivos / combina carpetas), skip, keepboth."""
|
|
dst = fm_clean(dst)
|
|
srcs = [fm_clean(x) for x in srcs]
|
|
if mode not in ("replace", "skip", "keepboth"):
|
|
mode = "replace"
|
|
for s in srcs:
|
|
if dst == s or dst.startswith(s + "/"):
|
|
raise E.PipeError("No se puede %s una carpeta dentro de si misma" % ("mover" if op == "move" else "copiar"))
|
|
cfg = cfg_snapshot()
|
|
bf = fm_bf_opt()
|
|
|
|
def bf_job(kind, s, d, overwrite):
|
|
bf._req("POST", "/api/fs/" + kind, form={"src": s, "dst": d, "overwrite": "1" if overwrite else "0"})
|
|
while True:
|
|
time.sleep(0.7)
|
|
if FM_CANCEL.is_set():
|
|
try:
|
|
bf._req("GET", "/api/fs/job/cancel")
|
|
except Exception:
|
|
pass
|
|
j = bf._req("GET", "/api/fs/job/status")
|
|
with LOCK:
|
|
FMOP.update(bytes_done=int(j.get("copiedBytes") or 0), bytes_total=int(j.get("totalBytes") or 0),
|
|
current=j.get("current") or s)
|
|
if not j.get("busy"):
|
|
if j.get("error"):
|
|
raise E.PipeError(j["error"])
|
|
break
|
|
if FM_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
|
|
def relay(s, target):
|
|
def prog(done, total, cur):
|
|
with LOCK:
|
|
FMOP.update(bytes_done=done, bytes_total=total, current=cur)
|
|
ftp_relay_copy(cfg, s, target, FM_CANCEL, prog)
|
|
|
|
def work():
|
|
taken = set(_names_in(dst))
|
|
for i, s in enumerate(srcs):
|
|
if FM_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
name = posixpath.basename(s)
|
|
same_dir = posixpath.dirname(s) == dst
|
|
with LOCK:
|
|
FMOP.update(current=s, items_done=i, bytes_done=0, bytes_total=0)
|
|
if op == "move" and same_dir:
|
|
continue
|
|
new = name
|
|
if name in taken:
|
|
if mode == "skip":
|
|
continue
|
|
if mode == "keepboth" or same_dir:
|
|
new = _free_name(name, taken)
|
|
taken.add(new)
|
|
target = dst.rstrip("/") + "/" + new
|
|
if bf is not None:
|
|
if new == name:
|
|
bf_job(op, s, dst, mode == "replace")
|
|
else:
|
|
# BFpilot copia con el mismo nombre: a una carpeta temporal y luego se renombra
|
|
tmp = "%s/.ps5d-%s" % (dst.rstrip("/"), secrets.token_hex(3))
|
|
bf.mkdir(tmp)
|
|
try:
|
|
bf_job(op, s, tmp, False)
|
|
bf.rename(tmp + "/" + name, target)
|
|
finally:
|
|
try:
|
|
bf.delete(tmp)
|
|
except Exception:
|
|
pass
|
|
else:
|
|
if op == "move":
|
|
try:
|
|
E.Ftp(cfg).call(lambda f: f.rename(s, target))
|
|
continue
|
|
except Exception:
|
|
pass # otro disco o ya existe: copia y luego borra
|
|
relay(s, target)
|
|
if op == "move":
|
|
ftp_rmtree(cfg, s, FM_CANCEL)
|
|
with LOCK:
|
|
FMOP["items_done"] = len(srcs)
|
|
_fm_start(op, len(srcs), work, where=dst, names=[posixpath.basename(x) for x in srcs])
|
|
|
|
|
|
def fm_delete(paths):
|
|
paths = [fm_clean(x) for x in paths]
|
|
for p in paths:
|
|
if p.count("/") < 2:
|
|
raise E.PipeError("Por seguridad no borro carpetas de primer nivel (%s)" % p)
|
|
bf = fm_bf_opt()
|
|
cfg = cfg_snapshot()
|
|
|
|
def free_now():
|
|
if bf is None:
|
|
return None
|
|
try:
|
|
return int(bf._req("GET", "/api/fs/stat", {"path": paths[0].rsplit("/", 1)[0] or "/"},
|
|
timeout=8).get("availableBytes") or 0)
|
|
except Exception:
|
|
return None
|
|
|
|
def work():
|
|
start = free_now()
|
|
last = {"t": 0.0}
|
|
|
|
def tick():
|
|
# Borrar un juego grande tarda: ensenamos lo que se va liberando para que se vea que avanza
|
|
if start is None or time.time() - last["t"] < 3:
|
|
return
|
|
last["t"] = time.time()
|
|
now = free_now()
|
|
if now is not None:
|
|
with LOCK:
|
|
FMOP["bytes_done"] = max(0, now - start)
|
|
FMOP["message"] = ""
|
|
for i, p in enumerate(paths):
|
|
if FM_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
with LOCK:
|
|
FMOP.update(current=p, items_done=i)
|
|
if bf is not None:
|
|
bf.delete(p, FM_CANCEL, on_tick=tick)
|
|
else:
|
|
ftp_rmtree(cfg, p, FM_CANCEL,
|
|
lambda rp, k, n: FMOP.update(current=rp))
|
|
tick()
|
|
with LOCK:
|
|
FMOP["items_done"] = len(paths)
|
|
if FMOP["bytes_done"]:
|
|
FMOP["message"] = "Hecho: liberados %s" % human(FMOP["bytes_done"])
|
|
_fm_start("delete", len(paths), work, where=posixpath.dirname(paths[0]) if paths else None,
|
|
names=[posixpath.basename(x) for x in paths])
|
|
|
|
|
|
def fm_du(path):
|
|
path = fm_clean(path)
|
|
bf = fm_bf_opt()
|
|
if bf is not None:
|
|
return bf.du(path, timeout=300)
|
|
return ftp_du(cfg_snapshot(), path)
|
|
|
|
|
|
def fm_extract(src, folder, password="", exists="keepboth"):
|
|
"""Descomprime un .rar/.7z/.zip que ya esta en la consola, en una carpeta a su lado."""
|
|
src = fm_clean(src)
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
if not bf.alive():
|
|
raise E.PipeError("Descomprimir en la consola necesita BFpilot cargado en la PS5")
|
|
parent, name = posixpath.dirname(src) or "/", posixpath.basename(src)
|
|
if not E.is_archive(name):
|
|
raise E.PipeError("Eso no es un comprimido (.rar, .7z o .zip)")
|
|
have = _names_in(parent)
|
|
# de un .part3.rar o un .7z.002 se extrae desde el primero
|
|
group = [n for n in have if not have[n] and E.set_key(n) == E.set_key(name) and E.is_archive(n)]
|
|
first = E.first_volume(group or [name]) or name
|
|
src = parent.rstrip("/") + "/" + first
|
|
folder = (folder or "").strip().strip("/")
|
|
if not folder or "/" in folder or folder in (".", ".."):
|
|
raise E.PipeError("Pon un solo nombre de carpeta, sin /")
|
|
if folder in have: # BFpilot no extrae sobre una carpeta que ya existe
|
|
folder = _free_name(folder, set(have))
|
|
dst = parent.rstrip("/") + "/" + folder
|
|
|
|
def work():
|
|
with LOCK:
|
|
FMOP.update(current=first)
|
|
|
|
def st(j):
|
|
with LOCK:
|
|
FMOP.update(bytes_done=int(j.get("bytesWritten") or 0), bytes_total=int(j.get("totalBytes") or 0),
|
|
current=j.get("current") or first)
|
|
try:
|
|
j = bf.extract(src, dst, password, FM_CANCEL, st)
|
|
except E.PipeError as e:
|
|
if E.is_password_error(str(e)):
|
|
raise E.PipeError("Contraseña incorrecta o necesaria: vuelve a intentarlo con la contraseña")
|
|
raise
|
|
try:
|
|
bf.fix_perms(dst, FM_CANCEL)
|
|
except Exception:
|
|
pass
|
|
with LOCK:
|
|
FMOP.update(items_done=1, message="Extraído en %s" % dst)
|
|
_fm_start("extract", 1, work, where=parent, names=[first])
|
|
|
|
|
|
def fm_download(paths):
|
|
cfg = cfg_snapshot()
|
|
paths = [fm_clean(x) for x in paths]
|
|
root_local = os.path.join(downloads_dir(), "PS5 Directo")
|
|
|
|
def walk(rpath):
|
|
"""[(ruta remota, ruta relativa, tamano)] de un archivo o carpeta."""
|
|
out = []
|
|
base = posixpath.basename(rpath)
|
|
listing = None
|
|
try:
|
|
listing = fm_list(rpath)["entries"]
|
|
except Exception:
|
|
listing = None
|
|
if listing is None:
|
|
return [(rpath, base, None)]
|
|
stack = [(rpath, base, listing)]
|
|
while stack:
|
|
cur, rel, ents = stack.pop()
|
|
for e in ents:
|
|
rp, rr = cur + "/" + e["name"], rel + "/" + e["name"]
|
|
if e["dir"]:
|
|
stack.append((rp, rr, fm_list(rp)["entries"]))
|
|
else:
|
|
out.append((rp, rr, e.get("size")))
|
|
return out
|
|
|
|
def work():
|
|
files = []
|
|
for p in paths:
|
|
parent = fm_list(posixpath.dirname(p) or "/")["entries"]
|
|
ent = next((e for e in parent if e["name"] == posixpath.basename(p)), None)
|
|
if ent and not ent["dir"]:
|
|
files.append((p, posixpath.basename(p), ent.get("size")))
|
|
else:
|
|
files.extend(walk(p))
|
|
total = sum(sz or 0 for _, _, sz in files)
|
|
with LOCK:
|
|
FMOP.update(items_total=len(files), bytes_total=total, local=root_local)
|
|
done = 0
|
|
for i, (rp, rel, sz) in enumerate(files):
|
|
if FM_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
with LOCK:
|
|
FMOP.update(current=rp, items_done=i)
|
|
local = os.path.join(root_local, *rel.split("/"))
|
|
if sz is not None and os.path.isfile(local) and os.path.getsize(local) == sz:
|
|
done += sz
|
|
continue
|
|
base = done
|
|
E.ftp_download(cfg, rp, local, FM_CANCEL, lambda n: FMOP.update(bytes_done=base + n), sz)
|
|
done = base + (sz or 0)
|
|
with LOCK:
|
|
FMOP.update(items_done=len(files), bytes_done=done,
|
|
message="Guardado en %s" % root_local)
|
|
_fm_start("download", len(paths), work, names=[posixpath.basename(x) for x in paths])
|
|
|
|
|
|
def fm_chmod(paths):
|
|
bf = fm_bf_opt()
|
|
cfg = cfg_snapshot()
|
|
paths = [fm_clean(x) for x in paths]
|
|
|
|
def work():
|
|
changed = 0
|
|
for i, p in enumerate(paths):
|
|
with LOCK:
|
|
FMOP.update(current=p, items_done=i)
|
|
if bf is not None:
|
|
c, _, _ = bf.fix_perms(p, FM_CANCEL)
|
|
else:
|
|
c = ftp_chmod_tree(cfg, p, FM_CANCEL)
|
|
changed += c
|
|
with LOCK:
|
|
FMOP.update(items_done=len(paths), message="Permisos 777 puestos en %d elementos" % changed)
|
|
_fm_start("chmod", len(paths), work)
|
|
|
|
|
|
PICK_SCRIPT = r'''
|
|
import json, sys, os
|
|
import tkinter as tk
|
|
from tkinter import filedialog
|
|
r = tk.Tk(); r.withdraw()
|
|
try:
|
|
r.attributes("-topmost", True)
|
|
except Exception:
|
|
pass
|
|
kind, title = sys.argv[1], sys.argv[2]
|
|
if kind == "folder":
|
|
p = filedialog.askdirectory(title=title, mustexist=True)
|
|
res = [p] if p else []
|
|
else:
|
|
res = list(filedialog.askopenfilenames(title=title))
|
|
print(json.dumps([os.path.normpath(x) for x in res]))
|
|
'''
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Pestana Espacio: que ocupa sitio en la consola (grafico de quesitos + lista)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
SPACE = {"busy": False, "root": "", "done": 0, "total": 0, "current": "", "result": None, "error": ""}
|
|
SPACE_CANCEL = threading.Event()
|
|
IMAGE_RE = re.compile(r"\.(exfat|ffpkg|ffpfsc?|ufs|img)$", re.I)
|
|
EXPAND = ("homebrew", "pkg") # carpetas cuyo contenido se ensena elemento a elemento
|
|
|
|
|
|
def title_name(text):
|
|
"""Nombre del juego/app en un param.json (o None)."""
|
|
try:
|
|
j = json.loads(text)
|
|
except Exception:
|
|
m = re.search(r'"titleName"\s*:\s*"([^"]+)"', text or "")
|
|
return m.group(1) if m else None
|
|
lp = j.get("localizedParameters") or {}
|
|
for lang in (lp.get("defaultLanguage"), "es-ES", "en-US", "en-GB"):
|
|
if lang and isinstance(lp.get(lang), dict) and lp[lang].get("titleName"):
|
|
return lp[lang]["titleName"]
|
|
for v in lp.values():
|
|
if isinstance(v, dict) and v.get("titleName"):
|
|
return v["titleName"]
|
|
return j.get("titleName")
|
|
|
|
|
|
def space_scan(root):
|
|
cfg = cfg_snapshot()
|
|
bf = E.BFpilot(cfg)
|
|
if not bf.alive():
|
|
raise E.PipeError("Para analizar el espacio hace falta BFpilot cargado en la PS5")
|
|
root = fm_clean(root or "/data")
|
|
st = bf._req("GET", "/api/fs/stat", {"path": root})
|
|
total = int(st.get("usableTotalBytes") or st.get("totalBytes") or 0)
|
|
free = int(st.get("availableBytes") or 0)
|
|
work = [] # (ruta, nombre, es_carpeta, tamano_listado, grupo)
|
|
for e in bf.listdir(root):
|
|
path = "%s/%s" % (root.rstrip("/"), e["name"])
|
|
if e.get("dir") and e["name"].lower() in EXPAND:
|
|
for c in bf.listdir(path):
|
|
work.append(("%s/%s" % (path, c["name"]), c["name"], bool(c.get("dir")), c.get("size") or 0,
|
|
e["name"].lower()))
|
|
else:
|
|
work.append((path, e["name"], bool(e.get("dir")), e.get("size") or 0, ""))
|
|
extra = []
|
|
if root == "/data":
|
|
extra.append(("/user/app", "Instalado desde la PS5", True, 0, "system"))
|
|
with LOCK:
|
|
SPACE.update(total=len(work) + len(extra), done=0)
|
|
items = []
|
|
for i, (path, name, is_dir, lsize, group) in enumerate(work + extra):
|
|
if SPACE_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
with LOCK:
|
|
SPACE.update(done=i, current=path)
|
|
size = bf.du(path, timeout=300) if is_dir else int(lsize or 0)
|
|
if size is None:
|
|
size = int(lsize or 0)
|
|
it = {"path": path, "name": name, "size": size, "dir": is_dir, "group": group,
|
|
"kind": "folder" if is_dir else "file", "title": None, "tid": None,
|
|
"deletable": True, "notes": []}
|
|
if group == "system":
|
|
it.update(kind="system", deletable=False)
|
|
it["notes"].append("Bórralos desde la consola: Ajustes > Almacenamiento")
|
|
elif group == "homebrew":
|
|
if is_dir and bf.exists(path + "/sce_sys/param.json"):
|
|
txt = bf.read_text(path + "/sce_sys/param.json")
|
|
it.update(kind="app", title=title_name(txt), tid=E.title_id(txt) or E.title_id(name))
|
|
elif IMAGE_RE.search(name):
|
|
it.update(kind="image", tid=E.title_id(name))
|
|
elif is_dir:
|
|
it["kind"] = "incomplete"
|
|
it["notes"].append("No tiene sce_sys: no es una app completa (¿envío cortado o copia a medias?)")
|
|
elif group == "pkg":
|
|
it["kind"] = "pkg"
|
|
it["notes"].append("Instalador .pkg: si ya está instalado, se puede borrar")
|
|
elif root == "/data" and name == "ps5directo":
|
|
it["kind"] = "leftover"
|
|
it["notes"].append("Restos de envíos de PS5 Directo")
|
|
elif root == "/data" and is_dir:
|
|
it["kind"] = "data"
|
|
it["notes"].append("Datos de payloads o ajustes: bórralo solo si sabes qué es")
|
|
if re.search(r"\.(ps5part|ava-part|part|tmp)$", name, re.I):
|
|
it["kind"] = "leftover"
|
|
it["notes"].append("Archivo a medias de un envío")
|
|
if is_dir and 0 < size < 1024 * 1024 and group == "homebrew":
|
|
it["notes"].append("Casi vacía (%s)" % human(size))
|
|
items.append(it)
|
|
# el mismo juego dos veces (por ejemplo la carpeta y la imagen convertida a lz4)
|
|
by_tid = {}
|
|
for it in items:
|
|
if it["tid"]:
|
|
by_tid.setdefault(it["tid"].upper(), []).append(it)
|
|
for tid, lst in by_tid.items():
|
|
if len(lst) > 1:
|
|
for it in lst:
|
|
others = [x["name"] for x in lst if x is not it]
|
|
it["dup"] = True
|
|
it["notes"].append("Duplicado: %s también está en %s" % (tid, ", ".join(others[:3])))
|
|
names = {k: v.get("title") for k, v in lib_load()["titles"].items() if v.get("title")}
|
|
names.update({it["tid"].upper(): it["title"] for it in items if it["tid"] and it["title"]})
|
|
for it in items:
|
|
if not it["title"] and it["tid"] and it["tid"].upper() in names:
|
|
it["title"] = names[it["tid"].upper()]
|
|
items.sort(key=lambda x: -x["size"])
|
|
used = max(0, total - free)
|
|
known = sum(x["size"] for x in items)
|
|
if extra and known > used: # /user/app no comparte particion: no lo contamos
|
|
items = [x for x in items if x["kind"] != "system"]
|
|
known = sum(x["size"] for x in items)
|
|
return {"root": root, "total": total, "free": free, "used": used,
|
|
"other": max(0, used - known), "items": items, "t": time.time()}
|
|
|
|
|
|
def space_start(root):
|
|
with LOCK:
|
|
if SPACE["busy"]:
|
|
raise E.PipeError("Ya se está analizando")
|
|
SPACE.update(busy=True, root=root, done=0, total=0, current="", error="")
|
|
SPACE_CANCEL.clear()
|
|
|
|
def run():
|
|
try:
|
|
res = space_scan(root)
|
|
with LOCK:
|
|
SPACE["result"] = res
|
|
except E.Cancelled:
|
|
with LOCK:
|
|
SPACE["error"] = "Cancelado"
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
with LOCK:
|
|
SPACE["error"] = str(e)
|
|
finally:
|
|
with LOCK:
|
|
SPACE["busy"] = False
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
|
|
def fm_api(p, b):
|
|
if p == "/api/space/scan":
|
|
space_start(str(b.get("root") or "/data"))
|
|
return {}
|
|
if p == "/api/space/state":
|
|
with LOCK:
|
|
return {"space": dict(SPACE)}
|
|
if p == "/api/space/cancel":
|
|
SPACE_CANCEL.set()
|
|
return {}
|
|
if p == "/api/fm/stat":
|
|
st = E.BFpilot(cfg_snapshot())._req("GET", "/api/fs/stat", {"path": fm_clean(b.get("path") or "/data")}, timeout=8)
|
|
return {"free": st.get("availableBytes"), "total": st.get("usableTotalBytes") or st.get("totalBytes")}
|
|
if p == "/api/fm/list":
|
|
return fm_list(b.get("path") or "/data")
|
|
if p == "/api/fm/du":
|
|
return {"size": fm_du(b.get("path"))}
|
|
if p == "/api/fm/dirs":
|
|
path = fm_clean(b.get("path") or "/data")
|
|
return {"path": path, "dirs": sorted([e["name"] for e in fm_list(path)["entries"] if e["dir"]],
|
|
key=str.lower)}
|
|
if p == "/api/fm/conflicts":
|
|
return {"conflicts": fm_conflicts(b.get("srcs") or [], b.get("dst") or "/")}
|
|
if p == "/api/fm/extract":
|
|
fm_extract(b.get("src"), b.get("folder"), str(b.get("password") or ""), b.get("exists") or "keepboth")
|
|
return {}
|
|
if p == "/api/fm/drives":
|
|
bf = fm_bf_opt()
|
|
out = [{"path": "/data", "name": "Almacenamiento interno"}]
|
|
if bf is not None:
|
|
for m in (bf.places() or {}).get("mounts") or []:
|
|
mp = (m.get("path") or "").rstrip("/")
|
|
if re.match(r"^/mnt/(usb|ext)\d+$", mp):
|
|
out.append({"path": mp, "name": ("USB " if "/usb" in mp else "Disco externo ") + mp[-1]})
|
|
for d in out:
|
|
try:
|
|
st = bf._req("GET", "/api/fs/stat", {"path": d["path"]}, timeout=6)
|
|
d["free"] = st.get("availableBytes")
|
|
d["total"] = st.get("usableTotalBytes") or st.get("totalBytes")
|
|
except Exception:
|
|
pass
|
|
return {"drives": out, "bfpilot": bf is not None}
|
|
if p == "/api/fm/mkdir":
|
|
path = fm_clean(b.get("path"))
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
if bf.alive():
|
|
bf.mkdir(path)
|
|
else:
|
|
E.Ftp(cfg_snapshot()).call(lambda f: f.mkd(path))
|
|
return {}
|
|
if p == "/api/report/diag":
|
|
j = find(str(b.get("id") or ""))
|
|
if not j:
|
|
raise E.PipeError("No encuentro esa transferencia")
|
|
d = diagnose(j)
|
|
d.update(error=j.get("error") or "", phase=j.get("phase") or "", log=list(j.get("log") or [])[-40:],
|
|
title=_job_name(j))
|
|
return d
|
|
if p == "/api/report/make":
|
|
fp = make_report(str(b.get("id") or "") or None)
|
|
return {"path": fp, "name": os.path.basename(fp)}
|
|
if p == "/api/report/open":
|
|
os.makedirs(report_dir(), exist_ok=True)
|
|
_open_quiet(report_dir())
|
|
return {"dir": report_dir()}
|
|
if p == "/api/lib/check":
|
|
return launch_check(str(b.get("path") or ""), int(b.get("minutes") or 30))
|
|
if p == "/api/lib/checkreport":
|
|
import zipfile
|
|
r = launch_check(str(b.get("path") or ""), int(b.get("minutes") or 30))
|
|
os.makedirs(report_dir(), exist_ok=True)
|
|
tag = re.sub(r"[^\w-]+", "_", r.get("title") or r.get("tid") or "aplicacion")[:40]
|
|
fp = os.path.join(report_dir(), "arranque-%s-%s.zip" % (tag, time.strftime("%Y-%m-%d_%H%M")))
|
|
with zipfile.ZipFile(fp, "w", zipfile.ZIP_DEFLATED) as z:
|
|
z.writestr("comprobacion.json", json.dumps({k: v for k, v in r.items() if k != "codes"},
|
|
ensure_ascii=False, indent=1))
|
|
z.writestr("codigo_de_error.txt", str(b.get("code") or ""))
|
|
z.writestr("ajustes_sin_contrasenas.json", json.dumps(_clean_settings(), ensure_ascii=False, indent=1))
|
|
for k, c in enumerate(r.get("captures") or []):
|
|
try:
|
|
cp, _ = media_cached(c["path"])
|
|
z.write(cp, "capturas/%d_%s" % (k, c["name"]))
|
|
except Exception:
|
|
pass
|
|
return {"path": fp, "name": os.path.basename(fp)}
|
|
if p == "/api/col/state":
|
|
with LOCK:
|
|
return {"col": dict(COL), "roots": list(SETTINGS.get("pc_collection") or [])}
|
|
if p == "/api/col/scan":
|
|
if not COL["busy"]:
|
|
threading.Thread(target=collection_scan, daemon=True).start()
|
|
return {}
|
|
if p == "/api/col/set":
|
|
roots = [str(x).strip().strip('"') for x in (b.get("roots") or []) if str(x).strip()]
|
|
with LOCK:
|
|
SETTINGS["pc_collection"] = roots
|
|
save_settings()
|
|
return {"roots": roots}
|
|
if p == "/api/media/list":
|
|
return {"items": media_list()}
|
|
if p == "/api/media/clearcache":
|
|
import shutil
|
|
shutil.rmtree(MEDIA_DIR, ignore_errors=True)
|
|
return {}
|
|
if p == "/api/bk/state":
|
|
with LOCK:
|
|
st = dict(BK)
|
|
st["dir"] = backup_dir()
|
|
st["last_t"] = SETTINGS.get("backup_last") or 0
|
|
return {"bk": st}
|
|
if p == "/api/bk/list":
|
|
return {"items": backup_list(), "dir": backup_dir()}
|
|
if p == "/api/bk/run":
|
|
if BK["busy"]:
|
|
raise E.PipeError("Ya hay una copia en marcha")
|
|
secs = [x for x in (b.get("sections") or []) if x in ("saves", "config", "appdb", "list")] or None
|
|
threading.Thread(target=backup_run, args=(secs,), daemon=True).start()
|
|
return {}
|
|
if p == "/api/bk/cancel":
|
|
BK_CANCEL.set()
|
|
return {}
|
|
if p == "/api/bk/restore":
|
|
if BK["busy"]:
|
|
raise E.PipeError("Espera a que termine la copia en marcha")
|
|
bpath = os.path.abspath(str(b.get("path") or ""))
|
|
if not bpath.startswith(os.path.abspath(backup_dir(cfg_snapshot()))) or not os.path.isfile(bpath):
|
|
raise E.PipeError("Esa copia ya no está en la carpeta de copias (¿la moviste o borraste?). "
|
|
"Pulsa Actualizar en la lista de copias.")
|
|
threading.Thread(target=backup_restore, args=(bpath, b.get("ids") or []), daemon=True).start()
|
|
return {}
|
|
if p == "/api/bk/open":
|
|
d = backup_dir()
|
|
os.makedirs(d, exist_ok=True)
|
|
_open_quiet(d)
|
|
return {"dir": d}
|
|
if p == "/api/gu/status":
|
|
return gu_status()
|
|
if p == "/api/gu/fix":
|
|
st = gu_status()
|
|
src = st.get("fix_from")
|
|
if not src:
|
|
raise E.PipeError("No hay nada que arreglar")
|
|
dst = "/data/homebrew/" + GU_TID
|
|
if st.get("present"):
|
|
raise E.PipeError("Ya existe %s" % dst)
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
if bf.alive():
|
|
bf.rename(src, dst)
|
|
else:
|
|
E.Ftp(cfg_snapshot()).call(lambda f: f.rename(src, dst))
|
|
parent = posixpath.dirname(src)
|
|
if parent != "/data/homebrew":
|
|
try:
|
|
E.Ftp(cfg_snapshot()).call(lambda f: f.rmd(parent)) # solo si se ha quedado vacia
|
|
except ftplib.all_errors:
|
|
pass
|
|
return {"path": dst}
|
|
if p == "/api/fm/rename":
|
|
src, dst = fm_clean(b.get("src")), fm_clean(b.get("dst"))
|
|
if posixpath.basename(dst) in _names_in(posixpath.dirname(dst) or "/"):
|
|
raise E.PipeError("Ya existe algo llamado %s en esa carpeta" % posixpath.basename(dst))
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
if bf.alive():
|
|
bf.rename(src, dst)
|
|
else:
|
|
E.Ftp(cfg_snapshot()).call(lambda f: f.rename(src, dst))
|
|
return {}
|
|
if p == "/api/fm/paste":
|
|
op = b.get("op")
|
|
if op not in ("copy", "move"):
|
|
raise E.PipeError("operacion no valida")
|
|
fm_paste(op, b.get("srcs") or [], b.get("dst"), b.get("mode") or ("replace" if b.get("overwrite") else "replace"))
|
|
return {}
|
|
if p == "/api/fm/delete":
|
|
fm_delete(b.get("paths") or [])
|
|
return {}
|
|
if p == "/api/fm/download":
|
|
fm_download(b.get("paths") or [])
|
|
return {}
|
|
if p == "/api/fm/chmod":
|
|
fm_chmod(b.get("paths") or [])
|
|
return {}
|
|
if p == "/api/fm/op":
|
|
with LOCK:
|
|
return {"op": dict(FMOP)}
|
|
if p == "/api/fm/cancel":
|
|
FM_CANCEL.set()
|
|
return {}
|
|
if p == "/api/fm/open_local":
|
|
path = FMOP.get("local") or os.path.join(downloads_dir(), "PS5 Directo")
|
|
if os.path.isdir(path):
|
|
_open_quiet(path)
|
|
return {"path": path}
|
|
if p == "/api/pick":
|
|
return {"paths": pick_paths(b.get("kind") or "files", b.get("title") or "")}
|
|
if p == "/api/history":
|
|
return {"items": read_history()}
|
|
if p == "/api/history/redo":
|
|
h = next((x for x in read_history() if x.get("id") == b.get("id")), None)
|
|
r = (h or {}).get("redo")
|
|
if not r or not r.get("lines"):
|
|
raise E.PipeError("No sé qué enlaces tenía esa transferencia (es de una versión anterior)")
|
|
nj = new_job(r["lines"], "", h.get("dest") or SETTINGS["dest"], title=h.get("title"), where=r.get("where"),
|
|
raw=r.get("raw"), fmt=r.get("fmt"), comp=r.get("comp"))
|
|
nj["fmt_set"] = r.get("fmt_set", False)
|
|
with WAKE:
|
|
JOBS.append(nj)
|
|
WAKE.notify_all()
|
|
save_jobs()
|
|
return {"id": nj["id"]}
|
|
if p == "/api/notifs":
|
|
with NOTIF_LOCK:
|
|
return {"items": list(NOTIFS), "unread": sum(1 for n in NOTIFS if not n.get("read"))}
|
|
if p == "/api/notifs/read":
|
|
with NOTIF_LOCK:
|
|
for n in NOTIFS:
|
|
if b.get("all") or n["id"] == b.get("id"):
|
|
n["read"] = not b.get("unread")
|
|
save_notifs()
|
|
return {}
|
|
if p == "/api/notifs/remove":
|
|
with NOTIF_LOCK:
|
|
NOTIFS[:] = [n for n in NOTIFS if n["id"] != b.get("id")]
|
|
save_notifs()
|
|
return {}
|
|
if p == "/api/notifs/clear":
|
|
with NOTIF_LOCK:
|
|
NOTIFS[:] = []
|
|
save_notifs()
|
|
return {}
|
|
if p == "/api/history/clear":
|
|
_save_json(HISTORY_FILE, [])
|
|
return {}
|
|
raise E.PipeError("no existe")
|
|
|
|
|
|
_DL_DIR = []
|
|
|
|
|
|
def downloads_dir():
|
|
"""Carpeta de Descargas del usuario. En Linux puede llamarse "Descargas" (xdg-user-dir)."""
|
|
if _DL_DIR:
|
|
return _DL_DIR[0]
|
|
d = os.path.join(os.path.expanduser("~"), "Downloads")
|
|
if sys.platform.startswith("linux"):
|
|
try:
|
|
import subprocess
|
|
r = subprocess.run(["xdg-user-dir", "DOWNLOAD"], capture_output=True, timeout=5)
|
|
x = r.stdout.decode("utf-8", "replace").strip()
|
|
if r.returncode == 0 and x and x != os.path.expanduser("~") and os.path.isdir(x):
|
|
d = x
|
|
except Exception:
|
|
pass
|
|
_DL_DIR.append(d)
|
|
return d
|
|
|
|
|
|
def _open_quiet(path):
|
|
try:
|
|
F.open_path(path)
|
|
except Exception as e:
|
|
print("No pude abrir %s: %s" % (path, e))
|
|
|
|
|
|
def pick_paths(kind, title):
|
|
"""Abre el dialogo del sistema para elegir archivos o una carpeta del PC."""
|
|
import subprocess
|
|
if os.name == "nt":
|
|
try:
|
|
return F.pick_windows(kind, title)
|
|
except Exception as e:
|
|
print("Selector de PowerShell:", e)
|
|
else:
|
|
try:
|
|
r = F.pick_native(kind, title)
|
|
if r is not None:
|
|
return r
|
|
except Exception as e:
|
|
print("Selector del sistema:", e)
|
|
exe = sys.executable
|
|
if os.name == "nt" and exe.lower().endswith("pythonw.exe"):
|
|
alt = exe[:-len("pythonw.exe")] + "python.exe"
|
|
exe = alt if os.path.isfile(alt) else exe
|
|
kw = {"creationflags": 0x08000000} if os.name == "nt" else {}
|
|
p = subprocess.run([exe, "-c", PICK_SCRIPT, kind, title or ""], stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE, timeout=3600, **kw)
|
|
if p.returncode != 0:
|
|
raise E.PipeError("No pude abrir el selector de archivos: %s"
|
|
% (p.stderr.decode("utf-8", "replace").strip().splitlines() or ["?"])[-1])
|
|
return json.loads(p.stdout.decode("utf-8", "replace").strip() or "[]")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Carpetas del PC: se mandan tal cual, saltando lo que ya este en la consola
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def folder_job(job, src, cancel):
|
|
cfg = cfg_snapshot()
|
|
cfg["_limit_bps"] = live_limit_bps
|
|
dest = (job.get("dest") or cfg["dest"]).rstrip("/")
|
|
tid = None
|
|
pj = os.path.join(src.path, "sce_sys", "param.json")
|
|
if os.path.isfile(pj):
|
|
try:
|
|
with open(pj, encoding="utf-8", errors="replace") as fh:
|
|
tid = E.title_id(fh.read())
|
|
except Exception:
|
|
pass
|
|
tid = tid or E.title_id(src.name)
|
|
name = (tid + "-app") if tid else src.name
|
|
target = dest + "/" + name
|
|
total = src.size
|
|
jlog(job, "Carpeta con %d archivos (%s) -> %s" % (len(src.files), human(total), target))
|
|
bf = E.BFpilot(cfg)
|
|
free = free_space(bf)
|
|
if free is not None:
|
|
jlog(job, "Espacio libre en la PS5: %s" % human(free))
|
|
if free < margin_bytes():
|
|
raise no_space(job, total, free,
|
|
"No hay sitio en la PS5: quedan %s libres y el margen es %s. Libera espacio "
|
|
"y pulsa Reintentar." % (human(free), human(margin_bytes())))
|
|
if tid and job_fmt(job) and not job.get("raw"):
|
|
# carpeta de un juego del PC -> imagen (o LZ4) con PS5 Dump Forge
|
|
res = forge_job(job, [src], cfg, cancel, src.path, [], "", Meter())
|
|
if res is not None:
|
|
return res
|
|
jlog(job, "La mando como carpeta normal")
|
|
if tid:
|
|
check_duplicates_first(job, bf, tid, exclude=target)
|
|
claim_target(job, target)
|
|
up = Meter()
|
|
last = {"v": 0, "t": 0.0}
|
|
stop_speed = threading.Event()
|
|
|
|
def speed_loop():
|
|
while not stop_speed.wait(1):
|
|
setj(job, speed=up.rate(), dl_speed=0.0)
|
|
threading.Thread(target=speed_loop, daemon=True).start()
|
|
|
|
def progress(v, rel):
|
|
if v > last["v"]:
|
|
up(v - last["v"])
|
|
last["v"] = v
|
|
now = time.time()
|
|
if now - last["t"] > 0.5:
|
|
last["t"] = now
|
|
setj(job, sent=v, phase="Enviando carpeta: %s" % rel[-80:])
|
|
|
|
setj(job, status="enviando", total=total, sent=0, phase="Comparando con lo que ya hay en la PS5")
|
|
def plan(need):
|
|
jlog(job, "Falta por enviar: %s" % human(need))
|
|
if free is not None and need > 0 and free - need < margin_bytes():
|
|
raise no_space(job, need, free,
|
|
"No cabe en la PS5: faltan %s por enviar, hay %s libres y el margen es %s. "
|
|
"Libera espacio y pulsa Reintentar." % (human(need), human(free), human(margin_bytes())))
|
|
|
|
watch = start_space_watch(job, bf, cancel, "el envio")
|
|
try:
|
|
sent, skipped, resumed = E.upload_tree(cfg, src, target, cancel, lambda m: jlog(job, m), progress,
|
|
on_plan=plan)
|
|
finally:
|
|
stop_speed.set()
|
|
watch.set()
|
|
setj(job, speed=0.0)
|
|
setj(job, sent=total)
|
|
jlog(job, "Carpeta enviada: %d archivos nuevos, %d ya estaban iguales, %d continuados"
|
|
% (sent, skipped, resumed))
|
|
if bf.alive():
|
|
fix_game_perms(job, bf, target, cancel)
|
|
return {"mode": "done", "placed": [target], "game": bool(tid)}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Alternativa: descomprimir en el PC con 7-Zip y mandar el contenido ya suelto
|
|
# ---------------------------------------------------------------------------
|
|
|
|
PCX_DIR = os.path.join(DATA_DIR, "pc_extract")
|
|
|
|
|
|
def job_where(job):
|
|
with LOCK:
|
|
w = job.get("where") or SETTINGS.get("extract_where") or "ps5"
|
|
return "pc" if w == "pc" else "ps5"
|
|
|
|
|
|
def job_fmt(job):
|
|
"""Formato con PS5 Dump Forge ('' = carpeta normal). Solo para lo que se prepara en el PC."""
|
|
with LOCK:
|
|
f = job.get("fmt")
|
|
if f is None or f == "" and not job.get("fmt_set"):
|
|
f = SETTINGS.get("pc_format") if job_where(job) == "pc" else ""
|
|
if job.get("_force_plain"):
|
|
return "plain" # sin 7-Zip: PS5 Dump Forge tambien sabe sacar el contenido a una carpeta
|
|
if f == "plain" and not job.get("_plain_conv"):
|
|
return "" # un comprimido normal ya acaba en carpeta: no hace falta Forge
|
|
return f if f in F.FORGE_FORMATS else ""
|
|
|
|
|
|
CONV_SRC_EXTS = E.IMAGE_EXTS + (".pkg",) # lo que Forge sabe deshacer o pasar a otro formato
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# PS5 Dump Forge: imagen .ffpkg / .ffpfsc o empaquetado LZ4, preparado en el PC
|
|
# ---------------------------------------------------------------------------
|
|
|
|
FORGE_LOCK = threading.Lock()
|
|
LIB_FILE = os.path.join(DATA_DIR, "library.json")
|
|
LIB_LOCK = threading.Lock()
|
|
COVER_DIR = os.path.join(DATA_DIR, "covers")
|
|
MEDIA_DIR = os.path.join(DATA_DIR, "media")
|
|
MEDIA_ROOT = "/user/av_contents"
|
|
MEDIA_TYPES = {".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp",
|
|
".jxr": "image/vnd.ms-photo", # capturas con la pantalla en HDR
|
|
".mp4": "video/mp4", ".webm": "video/webm", ".mov": "video/quicktime"}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Diagnostico e informe de fallo
|
|
# ---------------------------------------------------------------------------
|
|
|
|
DIAG_RULES = [
|
|
(r"(?i)10061|refused|rechaz|No route|timed out|unreachable|No puedo conectar con el FTP|conexi[oó]n con la PS5",
|
|
"No se pudo hablar con la consola por FTP.",
|
|
["Comprueba que la PS5 está encendida y que el servidor FTP (ftpsrv) está cargado: el punto de FTP arriba tiene que "
|
|
"estar en verde.", "Revisa la IP de la PS5 en Ajustes.",
|
|
"Si el PC y la PS5 están en redes distintas (por ejemplo 192.168.50.x y 192.168.1.x), conéctalos al mismo router.",
|
|
"En Ajustes, «Revisión completa» te dice qué falla."]),
|
|
(r"(?i)BFpilot", "BFpilot no responde o no está cargado.",
|
|
["Carga BFpilot en la consola (pulsa el punto de BFpilot arriba) y pulsa Reintentar.",
|
|
"Si no puedes usar BFpilot, elige «En el PC (7-Zip)» en «Dónde descomprimir»."]),
|
|
(r"(?i)No (cabe|hay sitio) en la PS5|Parado para no llenar|ESPACIO", "No hay espacio suficiente en la consola.",
|
|
["Libera espacio (pestaña Espacio → «Hacer sitio») y pulsa Reintentar: sigue donde iba.",
|
|
"O baja el margen que se deja libre en Ajustes."]),
|
|
(r"(?i)No cabe en el PC|No space left|Errno 28", "No hay espacio suficiente en el disco del PC.",
|
|
["Libera espacio en el PC o cambia la carpeta temporal en Ajustes a otro disco.",
|
|
"Sin convertir y descomprimiendo en la PS5 no hace falta sitio en el PC."]),
|
|
(r"(?i)contrase|password|encrypt", "El comprimido tiene contraseña y no se ha encontrado la buena.",
|
|
["Escribe la contraseña en la transferencia (o en Ajustes → contraseñas) y pulsa Reintentar."]),
|
|
(r"(?i)CRC|da[nñ]ad|corrupt|checksum|sumas", "Algún archivo ha llegado dañado o no cuadra con su comprobación.",
|
|
["Pulsa «Descargar de nuevo»: si vuelve a pasar, el archivo de origen está mal.",
|
|
"Si tiene contraseña, comprueba que es la correcta (una contraseña mala también da error de CRC)."]),
|
|
(r"(?i)HTTP (403|404|410)|caduc|expired|Forbidden|Not Found", "El enlace de descarga ya no vale (caducado o borrado).",
|
|
["Saca un enlace nuevo en la web de descarga y pégalo otra vez."]),
|
|
(r"(?i)Name or service not known|getaddrinfo|nodename nor servname|No se puede abrir el enlace|11001",
|
|
"El PC no ha podido llegar al servidor del enlace.",
|
|
["Comprueba que el PC tiene internet.", "Revisa que el enlace está bien copiado, entero y sin espacios.",
|
|
"Si es de tu NAS, comprueba que está encendido y que el nombre o la IP son correctos."]),
|
|
(r"(?i)quedo corta|se cort|Conexion cortada|connection reset|reset by peer|incompleta", "La descarga o el envío se cortó a medias.",
|
|
["Pulsa Reintentar: sigue donde iba, no empieza de cero.",
|
|
"Si pasa a menudo, prueba con cable de red o baja «Conexiones por archivo» en Ajustes."]),
|
|
(r"(?i)HTTP 429|limita las conexiones|Too Many", "El servidor de descarga está limitando las conexiones.",
|
|
["Espera unos minutos y pulsa Reintentar, o baja «Conexiones por archivo» en Ajustes."]),
|
|
(r"(?i)CE-107750|permis", "Problema de permisos: la consola no deja abrir los archivos.",
|
|
["En la Biblioteca pulsa «Permisos» en esa aplicación (pone 777)."]),
|
|
(r"(?i)pide (un )?firmware m[aá]s|no arrancar|solo funcionan con firmware|no te funcionar", "Pide un firmware más nuevo que el de tu PS5.",
|
|
["Busca una versión con backport para tu firmware o una versión anterior."]),
|
|
(r"(?i)Dump Forge|Forge:|convert", "Ha fallado la conversión de formato en el PC.",
|
|
["Prueba «Sin convertir» o «Carpeta»: el contenido se envía igual.",
|
|
"Si quieres convertir, prueba otro formato (.exfat suele ser el más compatible)."]),
|
|
(r"(?i)AMPR|LZ4", "LZ4 no vale para este contenido.",
|
|
["Elige «Sin convertir», «Carpeta» o «Imagen .exfat»."]),
|
|
(r"(?i)torrent|aria2", "No se pudo bajar el torrent.",
|
|
["Comprueba que el torrent tiene gente compartiendo (pares) y que el PC tiene internet.",
|
|
"Si el antivirus o el firewall bloquean aria2, dale permiso."]),
|
|
(r"(?i)Ya existe", "En la consola ya hay algo con ese nombre.",
|
|
["Elige en la cola si lo colocas igualmente con otro nombre, reemplazas lo que hay o cancelas."]),
|
|
]
|
|
|
|
|
|
def diagnose(job):
|
|
bad = [x for x in list(job.get("log") or [])[-60:]
|
|
if re.search(r"(?i)error|fallo|no pude|no se pudo|no puedo|aviso|warning|ojo|no cabe|no hay sitio|aria2:|HTTP \d{3}|corta", x)]
|
|
text = " ".join([job.get("error") or "", job.get("phase") or ""] + bad)
|
|
first = job.get("error") or ""
|
|
found, seen = [], set()
|
|
# primero lo que explica el error final; luego lo que sale en el registro
|
|
for src in (first, text):
|
|
for rx, cause, fixes in DIAG_RULES:
|
|
if cause in seen or not re.search(rx, src):
|
|
continue
|
|
seen.add(cause)
|
|
found.append({"cause": cause, "fixes": fixes})
|
|
if not found:
|
|
found.append({"cause": "No reconozco este error.",
|
|
"fixes": ["Pulsa Reintentar: muchos fallos de red se arreglan solos.",
|
|
"Si sigue fallando, guarda el informe y pásaselo a quien te ayude."]})
|
|
codes = sorted(set(re.findall(r"\b(CE-\d{6}-\d|HTTP \d{3}|Errno \d+|WinError \d+|errorCode=\d+|codigo -?\d+|código -?\d+|0x[0-9a-fA-F]{6,8})\b",
|
|
text)))
|
|
return {"items": found[:4], "codes": codes}
|
|
|
|
|
|
SECRET_KEYS = ("ftp_pass", "passwords", "lan_token", "token", "password")
|
|
|
|
|
|
def _clean_settings():
|
|
with LOCK:
|
|
st = dict(SETTINGS)
|
|
for k in list(st):
|
|
if any(x in k.lower() for x in SECRET_KEYS):
|
|
st[k] = "(oculto)" if st[k] else ""
|
|
return st
|
|
|
|
|
|
def _clean_job(j):
|
|
d = {k: v for k, v in j.items() if k not in ("password", "info")}
|
|
d["has_password"] = bool(j.get("password"))
|
|
return d
|
|
|
|
|
|
def _job_name(j):
|
|
if j.get("title"):
|
|
return j["title"]
|
|
src = (j.get("sources") or [{}])[0].get("name") or ((j.get("lines") or [""])[0].replace("\\", "/").rsplit("/", 1)[-1])
|
|
return src or "transferencia"
|
|
|
|
|
|
def report_dir():
|
|
return os.path.join(downloads_dir(), "PS5 Directo", "Informes")
|
|
|
|
|
|
def make_report(job_id=None):
|
|
"""Un .zip para pasar a quien te ayuda: registro, ajustes (sin contraseñas), versiones y estado."""
|
|
import zipfile
|
|
import platform
|
|
with LOCK:
|
|
jobs = [dict(j) for j in JOBS if job_id is None or j["id"] == job_id]
|
|
if job_id and not jobs:
|
|
raise E.PipeError("No encuentro esa transferencia")
|
|
os.makedirs(report_dir(), exist_ok=True)
|
|
tag = re.sub(r"[^\w-]+", "_", _job_name(jobs[0]) if job_id else "general")[:40]
|
|
fp = os.path.join(report_dir(), "informe-%s-%s.zip" % (tag, time.strftime("%Y-%m-%d_%H%M")))
|
|
forge = F.find_forge(SETTINGS.get("forge_path"), DATA_DIR)
|
|
info = {"app": "PS5 Directo", "version": VERSION, "date": time.strftime("%Y-%m-%d %H:%M:%S"),
|
|
"os": platform.platform(), "python": sys.version.split()[0],
|
|
"forge": os.path.basename(os.path.dirname(forge)) if forge else None,
|
|
"console_fw": SETTINGS.get("console_fw")}
|
|
try:
|
|
info["connection"] = test_connection(cfg_snapshot())
|
|
except Exception as e:
|
|
info["connection"] = str(e)
|
|
try:
|
|
info["network"] = net_mismatch(cfg_snapshot()) or "PC y PS5 en la misma red"
|
|
except Exception:
|
|
pass
|
|
summary = []
|
|
with zipfile.ZipFile(fp, "w", zipfile.ZIP_DEFLATED) as z:
|
|
z.writestr("version_y_conexion.json", json.dumps(info, ensure_ascii=False, indent=1))
|
|
z.writestr("ajustes_sin_contrasenas.json", json.dumps(_clean_settings(), ensure_ascii=False, indent=1))
|
|
for j in jobs:
|
|
name = re.sub(r"[^\w-]+", "_", (j.get("title") or j["id"]))[:40] + "_" + j["id"]
|
|
z.writestr("transferencias/%s.json" % name, json.dumps(_clean_job(j), ensure_ascii=False, indent=1))
|
|
z.writestr("transferencias/%s.txt" % name, "\n".join(j.get("log") or []))
|
|
dg = diagnose(j) if j.get("status") in ("error", "pausado", "cancelado") else None
|
|
summary.append("%s [%s]%s" % (j.get("title") or j["id"], j.get("status"),
|
|
(": " + (j.get("error") or "")) if j.get("error") else ""))
|
|
if dg:
|
|
for it in dg["items"]:
|
|
summary.append(" - " + it["cause"])
|
|
if job_id is None:
|
|
z.writestr("actividad.json", json.dumps(read_history()[-60:], ensure_ascii=False, indent=1))
|
|
with NOTIF_LOCK:
|
|
z.writestr("avisos.json", json.dumps(NOTIFS[:60], ensure_ascii=False, indent=1))
|
|
try: # registro tecnico del programa (sin el codigo de acceso de la sesion)
|
|
with open(os.path.join(DATA_DIR, "ps5directo.log"), encoding="utf-8", errors="replace") as fh:
|
|
lines = fh.readlines()[-400:]
|
|
z.writestr("registro_del_programa.txt",
|
|
"".join(re.sub(r"([#?&]t=)[\w-]+", r"\1(oculto)", ln) for ln in lines))
|
|
except OSError:
|
|
pass
|
|
z.writestr("LEEME.txt", "Informe de PS5 Directo %s (%s)\n\n%s\n\nNo lleva contraseñas. Pásaselo a quien te "
|
|
"ayude.\n" % (VERSION, info["date"], "\n".join(summary)))
|
|
return fp
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Comprobar arranque: por que una aplicacion de la Biblioteca no abre (solo lectura)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
LAUNCH_CODES = {
|
|
"CE-107750-0": "La consola no puede abrir los archivos: suele ser un problema de permisos. Pulsa «Permisos» "
|
|
"en la tarjeta (pone 777) y prueba otra vez.",
|
|
"CE-108255-1": "La aplicación se ha cerrado por un error al arrancar. Si es LZ4, prueba la versión sin convertir "
|
|
"o .exfat; si no, mira el firmware que pide y el backport.",
|
|
"CE-100005-6": "La consola no puede leer los datos: pueden estar incompletos o dañados. Vuelve a enviarla.",
|
|
"CE-100002-3": "Pide una versión del sistema más nueva. Busca una versión con backport para tu firmware.",
|
|
"CE-34878-0": "La aplicación se ha cerrado por un error. Prueba a reiniciar la consola y vuelve a abrirla; si "
|
|
"sigue, vuelve a enviarla o prueba otro formato.",
|
|
"CE-30005-8": "Error al leer los datos de la aplicación. Vuelve a enviarla.",
|
|
}
|
|
LOG_RX = re.compile(r"(?i)\.(log|txt)$")
|
|
|
|
|
|
def _console_now(f):
|
|
"""La hora segun la consola (su FTP puede ir con otra zona horaria que el PC): crea un archivo vacio en la
|
|
carpeta de trabajo, mira la fecha que le pone y lo borra."""
|
|
import io
|
|
p = WORK_ROOT + "/.reloj"
|
|
try:
|
|
E.Ftp.mkdirs(f, WORK_ROOT)
|
|
f.storbinary("STOR " + p, io.BytesIO(b""))
|
|
mt = dict(E.ftp_listdir(f, WORK_ROOT)).get(".reloj", {}).get("mtime")
|
|
try:
|
|
f.delete(p)
|
|
except ftplib.all_errors:
|
|
pass
|
|
return mt or time.time()
|
|
except ftplib.all_errors:
|
|
return time.time()
|
|
|
|
|
|
def _recent_logs(f, roots, since, limit=6):
|
|
"""Archivos .log/.txt modificados despues de 'since' (hasta 3 niveles), con sus ultimas lineas."""
|
|
found = []
|
|
|
|
def walk(path, depth):
|
|
try:
|
|
ls = E.ftp_listdir(f, path)
|
|
except ftplib.all_errors:
|
|
return
|
|
for n, v in ls:
|
|
p = path.rstrip("/") + "/" + n
|
|
if v["type"] == "dir":
|
|
if depth < 3 and n not in ("homebrew", "pkg", "ps5directo") and not n.startswith("."):
|
|
walk(p, depth + 1)
|
|
elif LOG_RX.search(n) and (v.get("mtime") or 0) >= since and (v.get("size") or 0) < 64 * 1024 * 1024:
|
|
found.append((v.get("mtime") or 0, p, v.get("size") or 0))
|
|
for r in roots:
|
|
walk(r, 0)
|
|
found.sort(reverse=True)
|
|
out = []
|
|
for mt, p, sz in found[:limit]:
|
|
try:
|
|
raw = F.ftp_read(f, p, max(0, sz - 6000), 6000).decode("utf-8", "replace")
|
|
except Exception:
|
|
raw = ""
|
|
out.append({"path": p, "mtime": mt, "tail": raw[-6000:]})
|
|
return out
|
|
|
|
|
|
def launch_check(path, minutes=30):
|
|
cfg = cfg_snapshot()
|
|
path = fm_clean(path)
|
|
checks = []
|
|
|
|
def add(level, text, fix=""):
|
|
checks.append({"level": level, "text": text, "fix": fix})
|
|
info = {}
|
|
|
|
def run(f):
|
|
is_dir = True
|
|
try:
|
|
ls = {n: v for n, v in E.ftp_listdir(f, path)}
|
|
except ftplib.all_errors:
|
|
is_dir = False
|
|
ls = {}
|
|
if not is_dir:
|
|
add("info", "Es una imagen (%s): lo de dentro solo se puede revisar cuando ShadowMountPlus la monta."
|
|
% posixpath.basename(path), "Si no aparece en el menú, prueba a enviarla como carpeta o .exfat.")
|
|
else:
|
|
sce = {}
|
|
if "sce_sys" in ls:
|
|
sce = {n: v for n, v in E.ftp_listdir(f, path + "/sce_sys")}
|
|
if "eboot.bin" in ls:
|
|
add("ok", "Tiene eboot.bin (el ejecutable principal).")
|
|
mode = ls["eboot.bin"].get("mode")
|
|
if mode is not None and (mode & 0o111) == 0:
|
|
add("bad", "eboot.bin no tiene permiso de ejecución.", "Pulsa «Permisos» en la tarjeta (pone 777).")
|
|
else:
|
|
add("bad", "Falta eboot.bin: la aplicación no puede arrancar.", "Vuelve a enviarla: está incompleta.")
|
|
if "param.json" in sce or "param.sfo" in sce:
|
|
add("ok", "Tiene sce_sys/param.json.")
|
|
else:
|
|
add("bad", "Falta sce_sys/param.json: la consola no sabe qué es.", "Vuelve a enviarla: está incompleta.")
|
|
if "icon0.png" not in sce:
|
|
add("warn", "Falta la portada (icon0.png). No impide arrancar.")
|
|
facts = {}
|
|
if "param.json" in sce:
|
|
try:
|
|
facts = F.param_facts(F.ftp_read(f, path + "/sce_sys/param.json", 0, 512 * 1024)
|
|
.decode("utf-8-sig", "replace"))
|
|
except Exception:
|
|
pass
|
|
info.update(tid=facts.get("tid") or E.title_id(posixpath.basename(path)), title=facts.get("title"))
|
|
fw_exe = None
|
|
if "eboot.bin" in ls:
|
|
try:
|
|
fw_exe = F.exe_firmware(lambda off, n: F.ftp_read(f, path + "/eboot.bin", off, n))
|
|
except Exception:
|
|
pass
|
|
backport = "fakelib" in ls or "fakelib2" in ls
|
|
need = (fw_exe if backport else None) or facts.get("fw_param") or fw_exe
|
|
mine = (SETTINGS.get("console_fw") or "").strip()
|
|
if need and mine:
|
|
ok = F.fw_ok(mine, need)
|
|
if ok is False:
|
|
add("bad", "Pide firmware %s y tu PS5 tiene %s." % (need, mine),
|
|
"Necesitas una versión con backport para tu firmware.")
|
|
elif ok:
|
|
add("ok", "Firmware: pide %s y tu PS5 tiene %s." % (need, mine))
|
|
elif need:
|
|
add("info", "Pide firmware %s. Pon el de tu PS5 en Ajustes para comprobarlo." % need)
|
|
if backport:
|
|
add("info", "Lleva backport (carpeta fakelib).")
|
|
# LZ4 / AMPR
|
|
amp = [n for n in ls if n.lower().startswith("ampr_assets")]
|
|
if amp:
|
|
vols = [n for n in amp if n.lower() != "ampr_assets.index" and not n.lower().endswith((".crc", ".runtime"))]
|
|
if "ampr_assets.index" not in [n.lower() for n in amp]:
|
|
add("bad", "Está empaquetada en LZ4 pero falta ampr_assets.index.", "Vuelve a convertirla o envíala sin convertir.")
|
|
else:
|
|
add("ok", "LZ4: tiene el índice de paquetes (%d archivos de datos)." % len(vols))
|
|
if not any(n.lower() == "ampr_emu.index" for n in ls):
|
|
add("warn", "LZ4: falta ampr_emu.index.", "Si no arranca, vuelve a convertirla o envíala sin convertir.")
|
|
if not any(n.lower().endswith(".runtime") for n in amp):
|
|
add("info", "LZ4: no lleva perfil .runtime (usa los valores por defecto). Si se cierra al arrancar, "
|
|
"es una causa habitual.", "Prueba a enviarla sin convertir, como carpeta o .exfat.")
|
|
empty = [n for n in vols if not ls[n].get("size")]
|
|
if empty:
|
|
add("bad", "LZ4: hay archivos de datos vacíos (%s)." % ", ".join(empty[:4]), "Vuelve a enviarla.")
|
|
fl = [d for d in ("fakelib", "fakelib2") if d in ls]
|
|
has_ampr = False
|
|
for d in fl:
|
|
try:
|
|
has_ampr |= any("ampr" in n.lower() for n, _ in E.ftp_listdir(f, path + "/" + d))
|
|
except ftplib.all_errors:
|
|
pass
|
|
if has_ampr:
|
|
add("ok", "LZ4: lleva el emulador AMPR en su fakelib.")
|
|
else:
|
|
add("warn", "LZ4: no encuentro el emulador AMPR (libSceAmpr) en fakelib.",
|
|
"Sin él los datos empaquetados no se pueden leer. Vuelve a convertirla.")
|
|
# backports de otras carpetas que pueden pisar los de esta
|
|
tid = (info.get("tid") or E.title_id(posixpath.basename(path)) or "").upper()
|
|
if tid:
|
|
for base in ("/data/shadowmount/backports", "/data/shadowmountplus/backports", WORK_ROOT + "/backports"):
|
|
try:
|
|
names = [n for n, v in E.ftp_listdir(f, base) if tid in n.upper()]
|
|
except ftplib.all_errors:
|
|
continue
|
|
for n in names:
|
|
add("warn", "Hay un backport aparte para este título en %s/%s, que puede sustituir al suyo." % (base, n),
|
|
"Si se cierra al arrancar, prueba a apartar esa carpeta.")
|
|
since = _console_now(f) - minutes * 60
|
|
info["logs"] = _recent_logs(f, ([path] if is_dir else []) + ["/data"], since)
|
|
E.Ftp(cfg).call(run)
|
|
lib = (LIB.get("items") or {}).get("items") or []
|
|
me = next((x for x in lib if x.get("path") == path), {})
|
|
if me.get("dup"):
|
|
add("warn", "Está repetida en %s: dos copias con el mismo Title ID pueden liar a ShadowMountPlus." % ", ".join(me["dup"]),
|
|
"Deja solo una.")
|
|
try:
|
|
caps = media_list()[:4]
|
|
except Exception:
|
|
caps = []
|
|
info.update(path=path, checks=checks, captures=caps, codes=LAUNCH_CODES)
|
|
return info
|
|
|
|
|
|
COL = {"busy": False, "items": None, "error": "", "t": 0, "current": ""}
|
|
COL_EXT = re.compile(r"(?i)\.(exfat|ffpkg|ffpfs|ffpfsc|pkg|zip|7z|rar|001)$")
|
|
|
|
|
|
def _local_dir_size(path, limit_s=8.0):
|
|
t0, total = time.time(), 0
|
|
for d, _dirs, fs in os.walk(path):
|
|
for n in fs:
|
|
try:
|
|
total += os.path.getsize(os.path.join(d, n))
|
|
except OSError:
|
|
pass
|
|
if time.time() - t0 > limit_s:
|
|
return None
|
|
return total
|
|
|
|
|
|
def collection_scan():
|
|
"""Lee las carpetas de la coleccion del PC: aplicaciones en carpeta (sce_sys), imagenes, .pkg y comprimidos."""
|
|
roots = [r for r in (SETTINGS.get("pc_collection") or []) if r]
|
|
with LOCK:
|
|
COL.update(busy=True, error="", current="")
|
|
items = []
|
|
try:
|
|
for root in roots:
|
|
if not os.path.isdir(root):
|
|
items.append({"path": root, "kind": "missing", "name": root})
|
|
continue
|
|
for d, dirs, fs in os.walk(root):
|
|
depth = d[len(root):].count(os.sep)
|
|
with LOCK:
|
|
COL["current"] = d
|
|
if "sce_sys" in dirs:
|
|
facts = {}
|
|
pj = os.path.join(d, "sce_sys", "param.json")
|
|
if os.path.isfile(pj):
|
|
try:
|
|
with open(pj, encoding="utf-8-sig", errors="replace") as fh:
|
|
facts = F.param_facts(fh.read())
|
|
except OSError:
|
|
pass
|
|
sfo = os.path.join(d, "sce_sys", "param.sfo")
|
|
if not facts.get("tid") and os.path.isfile(sfo):
|
|
with open(sfo, "rb") as fh:
|
|
facts = F.sfo_facts(fh.read())
|
|
items.append({"path": d, "kind": "folder", "name": os.path.basename(d),
|
|
"tid": facts.get("tid") or E.title_id(os.path.basename(d)),
|
|
"title": facts.get("title"), "version": facts.get("version"),
|
|
"need_fw": facts.get("fw_param") or facts.get("need_fw"),
|
|
"size": _local_dir_size(d), "icon": os.path.isfile(os.path.join(d, "sce_sys", "icon0.png"))})
|
|
dirs[:] = []
|
|
continue
|
|
if depth >= 4:
|
|
dirs[:] = []
|
|
for n in sorted(fs):
|
|
if not COL_EXT.search(n):
|
|
continue
|
|
low = n.lower()
|
|
# de los comprimidos por partes solo cuenta la primera (.part1.rar / .001)
|
|
if re.search(r"\.part0*([2-9]|[1-9]\d+)\.rar$", low):
|
|
continue
|
|
fp = os.path.join(d, n)
|
|
try:
|
|
sz = os.path.getsize(fp)
|
|
except OSError:
|
|
sz = None
|
|
kind = "image" if re.search(r"(?i)\.(exfat|ffpkg|ffpfs|ffpfsc)$", n) else (
|
|
"pkg" if low.endswith(".pkg") else "archive")
|
|
tid = E.title_id(n)
|
|
t = (lib_load().get("titles") or {}).get((tid or "").upper()) or {}
|
|
items.append({"path": fp, "kind": kind, "name": n, "tid": tid, "title": t.get("title"),
|
|
"size": sz, "ext": posixpath.splitext(low)[1].lstrip(".")})
|
|
with LOCK:
|
|
COL.update(items=items, t=time.time())
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
with LOCK:
|
|
COL["error"] = str(e)
|
|
finally:
|
|
with LOCK:
|
|
COL.update(busy=False, current="")
|
|
|
|
|
|
def col_icon(path):
|
|
path = os.path.abspath(path)
|
|
if not any(path.startswith(os.path.abspath(r)) for r in (SETTINGS.get("pc_collection") or []) if r):
|
|
return None
|
|
fp = os.path.join(path, "sce_sys", "icon0.png")
|
|
if os.path.isfile(fp):
|
|
with open(fp, "rb") as fh:
|
|
return fh.read()
|
|
return None
|
|
|
|
|
|
def media_list():
|
|
"""Capturas y videos de la consola (los mas nuevos primero). La PS5 los guarda en
|
|
/user/av_contents/{photo,video}/NPXS40087/<Title ID>/<carpeta>/<fecha>.jpg|jxr|webm."""
|
|
cfg = cfg_snapshot()
|
|
out = []
|
|
files = E.Ftp(cfg).call(lambda f: _ftp_walk_sizes(f, MEDIA_ROOT, [], threading.Event()))
|
|
titles = lib_load().get("titles") or {}
|
|
for p, sz in files:
|
|
ext = posixpath.splitext(p)[1].lower()
|
|
low = p.lower()
|
|
# miniaturas y copias temporales que hace la consola al compartir
|
|
if ext not in MEDIA_TYPES or "/thumbnail" in low or "/content_tmp/" in low:
|
|
continue
|
|
name = posixpath.basename(p)
|
|
tids = [c for c in p.split("/") if re.match(r"^[A-Z]{4}\d{5}$", c) and c != "NPXS40087"]
|
|
tid = tids[-1] if tids else ""
|
|
m = re.search(r"(20\d{2})(\d{2})(\d{2})_?(\d{2})(\d{2})(\d{2})?", name)
|
|
when = "%s-%s-%sT%s:%s:%s" % (m.group(1), m.group(2), m.group(3), m.group(4), m.group(5),
|
|
m.group(6) or "00") if m else ""
|
|
out.append({"path": p, "name": name, "size": sz,
|
|
"video": MEDIA_TYPES[ext].startswith("video"), "hdr": ext == ".jxr",
|
|
"tid": tid, "app": (titles.get(tid) or {}).get("title") or "",
|
|
"when": when, "folder": posixpath.basename(posixpath.dirname(p))})
|
|
out.sort(key=lambda x: (x["when"] or "", x["name"]), reverse=True)
|
|
return out[:3000]
|
|
|
|
|
|
def _jxr_to_jpg(src, dst):
|
|
"""Vista previa de una captura HDR (.jxr): Windows trae el decodificador de JPEG XR
|
|
(y en Mac se intenta con sips, la herramienta de imagenes del sistema)."""
|
|
if sys.platform == "darwin":
|
|
import subprocess
|
|
try:
|
|
r = subprocess.run(["sips", "-s", "format", "jpeg", src, "--out", dst], capture_output=True, timeout=60)
|
|
return r.returncode == 0 and os.path.isfile(dst) and os.path.getsize(dst) > 0
|
|
except Exception:
|
|
return False
|
|
if os.name != "nt":
|
|
return False
|
|
q = lambda t: "'" + t.replace("'", "''") + "'"
|
|
script = (
|
|
"Add-Type -AssemblyName PresentationCore;"
|
|
"$s=[IO.File]::OpenRead(%s);"
|
|
"try{ $d=[System.Windows.Media.Imaging.BitmapDecoder]::Create($s,"
|
|
" [System.Windows.Media.Imaging.BitmapCreateOptions]::None,"
|
|
" [System.Windows.Media.Imaging.BitmapCacheOption]::OnLoad) } finally { $s.Close() };"
|
|
"$c=New-Object System.Windows.Media.Imaging.FormatConvertedBitmap($d.Frames[0],"
|
|
" [System.Windows.Media.PixelFormats]::Bgr24, $null, 0);"
|
|
"$e=New-Object System.Windows.Media.Imaging.JpegBitmapEncoder; $e.QualityLevel=90;"
|
|
"$e.Frames.Add([System.Windows.Media.Imaging.BitmapFrame]::Create($c));"
|
|
"$o=[IO.File]::Create(%s); try{ $e.Save($o) } finally { $o.Close() }"
|
|
) % (q(src), q(dst))
|
|
r = _powershell(script, timeout=60)
|
|
return r.returncode == 0 and os.path.isfile(dst) and os.path.getsize(dst) > 0
|
|
|
|
|
|
def media_cached(path, preview=False):
|
|
"""Copia local (cache) de una captura o video, para verla en el navegador. Con preview,
|
|
una captura HDR (.jxr, que los navegadores no abren) se da convertida a JPG."""
|
|
import hashlib
|
|
path = fm_clean(path)
|
|
if not path.startswith(MEDIA_ROOT + "/"):
|
|
raise E.PipeError("Ruta no permitida")
|
|
ext = posixpath.splitext(path)[1].lower()
|
|
if ext not in MEDIA_TYPES:
|
|
raise E.PipeError("Tipo no admitido")
|
|
os.makedirs(MEDIA_DIR, exist_ok=True)
|
|
fp = os.path.join(MEDIA_DIR, hashlib.sha1(path.encode("utf-8")).hexdigest()[:20] + ext)
|
|
if not os.path.isfile(fp):
|
|
with open(fp + ".part", "wb") as fo:
|
|
E.Ftp(cfg_snapshot()).call(lambda f: f.retrbinary("RETR " + path, fo.write, 1024 * 1024))
|
|
os.replace(fp + ".part", fp)
|
|
if preview and ext == ".jxr":
|
|
jpg = fp[:-4] + "_vista.jpg"
|
|
if os.path.isfile(jpg) or _jxr_to_jpg(fp, jpg):
|
|
return jpg, "image/jpeg"
|
|
return fp, MEDIA_TYPES[ext]
|
|
FMT_LABEL = {"plain": "carpeta normal", "ffpkg": "imagen .ffpkg", "exfat": "imagen .exfat", "ffpfs": "imagen .ffpfs",
|
|
"ffpfsc": "imagen comprimida .ffpfsc", "fpkg": "paquete .fpkg", "lz4": "carpeta LZ4",
|
|
"lz4ffpkg": "imagen .ffpkg con LZ4"}
|
|
FPKG_MAX_FW = "11.60"
|
|
|
|
|
|
def lib_load():
|
|
try:
|
|
with open(LIB_FILE, encoding="utf-8") as f:
|
|
d = json.load(f)
|
|
d.setdefault("entries", {})
|
|
d.setdefault("titles", {})
|
|
return d
|
|
except Exception:
|
|
return {"entries": {}, "titles": {}}
|
|
|
|
|
|
def lib_save(d):
|
|
try:
|
|
with LIB_LOCK:
|
|
_save_json(LIB_FILE, d)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def remember_title(tid, title=None, need_fw=None, fw_param=None, cover_data_url=None, extra=None):
|
|
"""Guarda lo que se sabe de un juego por su Title ID (para ensenar imagenes con nombre y portada)."""
|
|
if not tid:
|
|
return
|
|
import base64
|
|
d = lib_load()
|
|
t = d["titles"].get(tid.upper(), {})
|
|
if title:
|
|
t["title"] = title
|
|
if need_fw:
|
|
t["need_fw"] = need_fw
|
|
if fw_param:
|
|
t["fw_param"] = fw_param
|
|
if extra:
|
|
t.update(extra)
|
|
if cover_data_url and cover_data_url.startswith("data:image/png;base64,"):
|
|
try:
|
|
os.makedirs(COVER_DIR, exist_ok=True)
|
|
fn = "tid-%s.png" % re.sub(r"[^\w]", "", tid.upper())
|
|
with open(os.path.join(COVER_DIR, fn), "wb") as fo:
|
|
fo.write(base64.b64decode(cover_data_url.split(",", 1)[1]))
|
|
t["cover"] = fn
|
|
except Exception:
|
|
pass
|
|
d["titles"][tid.upper()] = t
|
|
lib_save(d)
|
|
|
|
|
|
def forge_maybe_update(job, cfg, exe):
|
|
"""Una vez al dia, al convertir: si hay un PS5 Dump Forge mas nuevo en GitHub, lo baja y lo usa. Antes comprueba
|
|
que entiende las opciones que usa PS5 Directo; si no, sigue con la version que ya funcionaba."""
|
|
import shutil
|
|
if (cfg.get("forge_path") or "").strip() or not cfg.get("forge_auto_update", True):
|
|
return exe
|
|
now = time.time()
|
|
if now - float(SETTINGS.get("forge_checked") or 0) < 24 * 3600:
|
|
return exe
|
|
with LOCK:
|
|
SETTINGS["forge_checked"] = now
|
|
save_settings()
|
|
try:
|
|
tag, assets = F.github_release(F.FORGE_REPO)
|
|
except Exception as e:
|
|
jlog(job, "No pude mirar si hay PS5 Dump Forge nuevo (%s): sigo con el que hay" % e)
|
|
return exe
|
|
safe = re.sub(r"[^\w.-]", "_", tag or "")
|
|
bad = set(SETTINGS.get("forge_bad") or [])
|
|
have = os.path.basename(os.path.dirname(exe))
|
|
if not safe or safe == have or safe in bad or os.path.isdir(os.path.join(DATA_DIR, "tools", "forge", safe)):
|
|
return exe
|
|
setj(job, phase="Actualizando PS5 Dump Forge a la %s" % tag)
|
|
try:
|
|
new, _ = F.download_forge(DATA_DIR, log=lambda m: jlog(job, m), release=(tag, assets))
|
|
except Exception as e:
|
|
jlog(job, "No pude bajar PS5 Dump Forge %s (%s): sigo con el que hay" % (tag, e))
|
|
return exe
|
|
ok = F.forge_cli_ok(new)
|
|
if ok is False:
|
|
with LOCK:
|
|
SETTINGS["forge_bad"] = sorted(bad | {safe})
|
|
save_settings()
|
|
shutil.rmtree(os.path.dirname(new), ignore_errors=True)
|
|
jlog(job, "PS5 Dump Forge %s ha cambiado sus opciones y PS5 Directo aún no las conoce: sigo con %s" % (tag, have))
|
|
notify("warn", "PS5 Dump Forge %s no es compatible todavía" % tag,
|
|
"Sigo usando la %s, que funciona. Saldrá una versión de PS5 Directo que la admita." % have,
|
|
key="forgebad:" + safe)
|
|
return exe
|
|
jlog(job, "PS5 Dump Forge actualizado a la %s (antes %s)" % (tag, have))
|
|
# se guardan las dos ultimas versiones; las mas viejas se borran
|
|
root = os.path.join(DATA_DIR, "tools", "forge")
|
|
olds = sorted((d for d in os.listdir(root) if d not in (safe, have)),
|
|
key=lambda d: os.path.getmtime(os.path.join(root, d)))
|
|
for d in olds:
|
|
shutil.rmtree(os.path.join(root, d), ignore_errors=True)
|
|
return new
|
|
|
|
|
|
def ensure_forge(job, cfg):
|
|
exe = F.find_forge(cfg.get("forge_path"), DATA_DIR, skip=tuple(SETTINGS.get("forge_bad") or ()))
|
|
if exe:
|
|
return forge_maybe_update(job, cfg, exe)
|
|
with FORGE_LOCK:
|
|
exe = F.find_forge(cfg.get("forge_path"), DATA_DIR)
|
|
if exe:
|
|
return exe
|
|
setj(job, phase="Descargando PS5 Dump Forge de GitHub (solo la primera vez)")
|
|
try:
|
|
exe, tag = F.download_forge(DATA_DIR, log=lambda m: jlog(job, m))
|
|
except Exception as e:
|
|
raise E.PipeError("No pude descargar PS5 Dump Forge (%s). Bájalo de "
|
|
"github.com/quer3q/ps5-dump-forge y pon la ruta de ps5-dump-forge.exe en "
|
|
"Ajustes, o elige 'Carpeta normal'." % e)
|
|
jlog(job, "PS5 Dump Forge %s listo" % tag)
|
|
return exe
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Torrents (magnet o .torrent): se bajan al PC con aria2 y luego siguen como un archivo del PC
|
|
# ---------------------------------------------------------------------------
|
|
|
|
ARIA2_URL = "https://github.com/aria2/aria2/releases/download/release-1.37.0/aria2-1.37.0-win-64bit-build1.zip"
|
|
ARIA2_LOCK = threading.Lock()
|
|
_UNITS = {"B": 1, "KIB": 1024, "MIB": 1024 ** 2, "GIB": 1024 ** 3, "TIB": 1024 ** 4}
|
|
_ARIA_RX = re.compile(r"\[#(\w+)\s+([\d.]+)(\w*B)/([\d.]+)(\w*B)(?:\((\d+)%\))?([^\]]*)\]")
|
|
_PLAY_RX = re.compile(r"(?i)\.(rar|r\d{2,3}|zip|z\d{2}|7z|\d{3}|tar|tgz|gz|bz2|xz|exfat|ffpkg|ffpfs|ffpfsc|ufs|pkg|"
|
|
r"sfv|md5|sha1)$")
|
|
|
|
|
|
def is_torrent(line):
|
|
t = (line or "").strip().strip('"')
|
|
return bool(re.match(r"(?i)^magnet:\?", t)) or t.lower().split("?")[0].endswith(".torrent")
|
|
|
|
|
|
def _bytes(num, unit):
|
|
return int(float(num) * _UNITS.get(unit.upper(), 1))
|
|
|
|
|
|
def torrent_name(line):
|
|
t = line.strip().strip('"')
|
|
m = re.search(r"(?i)[?&]dn=([^&]+)", t)
|
|
if m:
|
|
return urllib.parse.unquote_plus(m.group(1))
|
|
base = t.split("?")[0].replace("\\", "/").rsplit("/", 1)[-1]
|
|
return re.sub(r"(?i)\.torrent$", "", urllib.parse.unquote(base)) or "torrent"
|
|
|
|
|
|
def ensure_aria2(job, cfg):
|
|
import shutil
|
|
custom = (cfg.get("aria2_path") or "").strip().strip('"')
|
|
if custom and os.path.isfile(custom):
|
|
return custom
|
|
mine = os.path.join(DATA_DIR, "tools", "aria2", "aria2c.exe" if os.name == "nt" else "aria2c")
|
|
if os.path.isfile(mine):
|
|
return mine
|
|
local = os.path.join(HERE, "aria2c.exe" if os.name == "nt" else "aria2c")
|
|
if os.path.isfile(local):
|
|
return local
|
|
w = shutil.which("aria2c")
|
|
if w:
|
|
return w
|
|
if os.name != "nt":
|
|
if sys.platform == "darwin":
|
|
raise E.PipeError("Para bajar torrents hace falta aria2. Instálalo con Homebrew (brew.sh): brew install aria2")
|
|
raise E.PipeError("Para bajar torrents hace falta aria2 (instálalo, por ejemplo: sudo apt install aria2)")
|
|
with ARIA2_LOCK:
|
|
if os.path.isfile(mine):
|
|
return mine
|
|
setj(job, phase="Descargando aria2 para los torrents (solo la primera vez)")
|
|
jlog(job, "Descargando aria2 (el programa que baja los torrents)…")
|
|
os.makedirs(os.path.dirname(mine), exist_ok=True)
|
|
tmp = mine + ".zip"
|
|
try:
|
|
F.http_get(ARIA2_URL, limit=50 * 1024 * 1024, timeout=120, dest=tmp)
|
|
import zipfile
|
|
with zipfile.ZipFile(tmp) as z:
|
|
n = next((x for x in z.namelist() if x.lower().endswith("/aria2c.exe")), None)
|
|
if not n:
|
|
raise E.PipeError("el .zip de aria2 no trae aria2c.exe")
|
|
with z.open(n) as src, open(mine + ".tmp", "wb") as dst:
|
|
shutil.copyfileobj(src, dst)
|
|
os.replace(mine + ".tmp", mine)
|
|
except Exception as e:
|
|
raise E.PipeError("No pude descargar aria2 para los torrents (%s). Bájalo de github.com/aria2/aria2 y "
|
|
"copia aria2c.exe en la carpeta de PS5 Directo." % e)
|
|
finally:
|
|
try:
|
|
os.remove(tmp)
|
|
except OSError:
|
|
pass
|
|
jlog(job, "aria2 listo")
|
|
return mine
|
|
|
|
|
|
def run_aria2(job, exe, line, root, cancel):
|
|
"""Baja un torrent a root. Devuelve cuando ha terminado (sin compartir despues)."""
|
|
import subprocess
|
|
import shutil
|
|
t = line.strip().strip('"')
|
|
args = [exe, "--dir=" + root, "--seed-time=0", "--bt-save-metadata=true", "--continue=true",
|
|
"--file-allocation=none", "--summary-interval=1", "--show-console-readout=false",
|
|
"--console-log-level=warn", "--enable-color=false", "--auto-save-interval=5",
|
|
"--bt-detach-seed-only=true", "--auto-file-renaming=false", "--allow-overwrite=false",
|
|
"--check-certificate=false" if os.name != "nt" else "--check-certificate=true"]
|
|
if not re.match(r"(?i)^(magnet:|https?://)", t):
|
|
if not os.path.isfile(t):
|
|
raise E.PipeError("No encuentro el archivo .torrent: %s" % t)
|
|
args += ["--torrent-file=" + t]
|
|
else:
|
|
args += [t]
|
|
name = torrent_name(t)
|
|
with LOCK:
|
|
if not job.get("title"):
|
|
job["title"] = name
|
|
job["sources"] = [{"input": t[:200], "name": name, "size": -1, "kind": "url"}]
|
|
setj(job, status="enviando", pc_step="bajar", phase="Torrent: buscando pares y datos del torrent…",
|
|
speed_label="Descarga del torrent", sent_label="Bajado al PC", sent=0, total=-1, speed=0.0, dl_speed=0.0)
|
|
jlog(job, "Bajando el torrent al PC con aria2 en %s" % root)
|
|
os.makedirs(root, exist_ok=True)
|
|
proc = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
|
creationflags=E._NOWIN, cwd=root)
|
|
tail, checked = [], {"space": False}
|
|
|
|
def reader():
|
|
for raw in proc.stdout:
|
|
ln = raw.decode("utf-8", "replace").rstrip()
|
|
if not ln:
|
|
continue
|
|
m = _ARIA_RX.search(ln)
|
|
if not m:
|
|
if ln.startswith(("FILE:", "***", "===", "---")) or "Download Progress Summary" in ln:
|
|
continue
|
|
# aria2 avisa de cosas sin importancia (DHT, IPv6) como "ERROR": solo se muestran si al final falla
|
|
tail.append(ln)
|
|
del tail[:-15]
|
|
continue
|
|
done, tot = _bytes(m.group(2), m.group(3)), _bytes(m.group(4), m.group(5))
|
|
rest = m.group(7) or ""
|
|
dl = re.search(r"DL:([\d.]+)(\w*B)", rest)
|
|
cn = re.search(r"CN:(\d+)", rest)
|
|
sd = re.search(r"SD:(\d+)", rest)
|
|
speed = _bytes(dl.group(1), dl.group(2)) if dl else 0
|
|
if tot <= 0 or "[METADATA]" in ln:
|
|
setj(job, phase="Torrent: consiguiendo los datos del torrent (%s conexiones)" % (cn.group(1) if cn else "0"))
|
|
continue
|
|
if not checked["space"]:
|
|
checked["space"] = True
|
|
free = shutil.disk_usage(root).free
|
|
with LOCK:
|
|
job["sources"] = [{"input": t[:200], "name": name, "size": tot, "kind": "url"}]
|
|
if tot + GiB > free:
|
|
job["_stop"] = ("No cabe en el PC: el torrent ocupa %s y en %s hay %s libres. Libera espacio o "
|
|
"cambia la carpeta temporal en Ajustes." % (human(tot), root, human(free)))
|
|
cancel.set()
|
|
peers = ("%s conexiones%s" % (cn.group(1), (", %s compartiendo" % sd.group(1)) if sd else "")) if cn else ""
|
|
setj(job, sent=done, total=tot, speed=float(speed), dl_speed=float(speed),
|
|
phase="Bajando el torrent al PC: %d%%%s" % (int(done * 100 / tot), (" · " + peers) if peers else ""))
|
|
th = threading.Thread(target=reader, daemon=True)
|
|
th.start()
|
|
while proc.poll() is None:
|
|
if cancel.is_set():
|
|
try:
|
|
proc.terminate()
|
|
proc.wait(10)
|
|
except Exception:
|
|
proc.kill()
|
|
raise E.Cancelled()
|
|
time.sleep(0.5)
|
|
th.join(5)
|
|
if proc.returncode != 0:
|
|
for x in tail[-8:]:
|
|
jlog(job, "aria2: " + x[:200])
|
|
msg = " ".join(x for x in tail[-4:] if x)[-300:] or ("código %s" % proc.returncode)
|
|
raise E.PipeError("No se pudo bajar el torrent: %s" % msg)
|
|
setj(job, sent=max(job.get("total") or 0, job.get("sent") or 0), speed=0.0, dl_speed=0.0)
|
|
jlog(job, "Torrent bajado al PC")
|
|
|
|
|
|
def torrent_outputs(root):
|
|
"""Lo que se ha bajado, convertido en lineas para la cola: aplicaciones (carpetas con sce_sys), comprimidos e
|
|
imagenes; si no hay nada de eso, la carpeta tal cual."""
|
|
tops = [os.path.join(root, n) for n in sorted(os.listdir(root))
|
|
if not n.lower().endswith((".aria2", ".torrent")) and not n.startswith(".")]
|
|
apps, files = [], []
|
|
for top in tops:
|
|
if os.path.isfile(top):
|
|
files.append(top)
|
|
continue
|
|
for d, dirs, fs in os.walk(top):
|
|
if "sce_sys" in dirs:
|
|
apps.append(d)
|
|
dirs[:] = []
|
|
continue
|
|
dirs.sort()
|
|
for f in sorted(fs):
|
|
if not f.lower().endswith(".aria2"):
|
|
files.append(os.path.join(d, f))
|
|
play = [f for f in files if _PLAY_RX.search(f)]
|
|
out = apps + play
|
|
if not out:
|
|
out = tops
|
|
return out
|
|
|
|
|
|
def torrent_stage(job, cfg, cancel):
|
|
lines = list(job["lines"])
|
|
tor = [l for l in lines if is_torrent(l)]
|
|
rest = [l for l in lines if not is_torrent(l)]
|
|
with LOCK:
|
|
job.setdefault("orig_lines", lines)
|
|
job["torrent"] = True
|
|
exe = ensure_aria2(job, cfg)
|
|
root = os.path.join(pc_temp_root(cfg), "torrent", job["id"])
|
|
for t in tor:
|
|
run_aria2(job, exe, t, root, cancel)
|
|
local = torrent_outputs(root)
|
|
if not local:
|
|
raise E.PipeError("El torrent no ha dejado nada en %s" % root)
|
|
jlog(job, "Del torrent sale: %s" % ", ".join(os.path.relpath(x, root) for x in local[:8]) +
|
|
(" y %d más" % (len(local) - 8) if len(local) > 8 else ""))
|
|
with LOCK:
|
|
job["lines"] = local + rest
|
|
job["torrent_dir"] = root
|
|
setj(job, status="comprobando", pc_step="enviar", speed_label="", sent_label="", sent=0, total=-1)
|
|
save_jobs()
|
|
|
|
|
|
def torrent_forget(job):
|
|
"""Al quitar un trabajo de torrent de la cola, lo bajado al PC ya no sirve: se borra."""
|
|
if not job.get("torrent"):
|
|
return
|
|
import shutil
|
|
d = job.get("torrent_dir") or os.path.join(pc_temp_root(cfg_snapshot()), "torrent", job["id"])
|
|
threading.Thread(target=shutil.rmtree, args=(d, True), daemon=True).start()
|
|
|
|
|
|
def torrent_cleanup(job):
|
|
d = job.get("torrent_dir")
|
|
if d and os.path.isdir(d) and cfg_snapshot().get("delete_archives", True):
|
|
import shutil
|
|
shutil.rmtree(d, ignore_errors=True)
|
|
jlog(job, "Borrado del PC lo bajado del torrent")
|
|
|
|
|
|
def check_fw_warning(job, tid, title, need_fw, fw_param=None, backport=False):
|
|
"""Aviso si el juego pide un firmware mas nuevo que el de tu PS5 (Ajustes)."""
|
|
with LOCK:
|
|
mine = SETTINGS.get("console_fw") or ""
|
|
if not need_fw:
|
|
return
|
|
ok = F.fw_ok(mine, need_fw)
|
|
name = title or tid or "Esta aplicación"
|
|
extra = " (con backport)" if backport else ""
|
|
if ok is None:
|
|
jlog(job, "%s pide firmware %s%s" % (name, need_fw, extra))
|
|
return
|
|
if ok:
|
|
jlog(job, "Firmware: %s pide %s%s y tu PS5 tiene %s: vale" % (name, need_fw, extra, mine))
|
|
return
|
|
msg = ("Ojo: %s pide firmware %s%s y tu PS5 tiene %s: lo más probable es que no arranque. Busca una "
|
|
"versión con backport para tu firmware." % (name, need_fw, extra, mine))
|
|
jlog(job, msg)
|
|
with LOCK:
|
|
job["warning"] = msg
|
|
notify("warn", "No arrancará en tu firmware: %s" % name, msg, {"tab": "Transfers", "job": job["id"]},
|
|
key="fw:%s:%s" % (job["id"], tid))
|
|
|
|
|
|
def _dir_size(path):
|
|
total = 0
|
|
for root, _, files in os.walk(path):
|
|
for n in files:
|
|
try:
|
|
total += os.path.getsize(os.path.join(root, n))
|
|
except OSError:
|
|
pass
|
|
return total
|
|
|
|
|
|
def send_local_as_is(job, cfg, path, cancel, up):
|
|
"""Manda un archivo del PC tal cual a la carpeta de destino (por ejemplo, una imagen ya hecha)."""
|
|
dest = (job.get("dest") or cfg["dest"]).rstrip("/")
|
|
name = os.path.basename(path)
|
|
target = dest + "/" + name
|
|
fs = E.FileSource(path).probe()
|
|
jlog(job, "Lo envío tal cual: %s" % name)
|
|
claim_target(job, target)
|
|
setj(job, status="enviando", pc_step="enviar", total=fs.size, sent=0, phase="Enviando %s" % name)
|
|
last = {"v": 0}
|
|
|
|
def progress(v, *_):
|
|
if v > last["v"]:
|
|
up(v - last["v"])
|
|
last["v"] = v
|
|
setj(job, sent=v, speed=up.rate())
|
|
E.upload(cfg, target, fs.size, lambda off: fs.stream(off, cfg, cancel, lambda n: None), progress, cancel,
|
|
lambda m: jlog(job, m))
|
|
setj(job, sent=fs.size)
|
|
with LOCK:
|
|
job["_placed_game"] = name.lower().endswith(E.IMAGE_EXTS)
|
|
return {"mode": "done", "placed": [target], "game": job["_placed_game"]}
|
|
|
|
|
|
def forge_split_archive(job, cfg, cancel, archive, cands):
|
|
"""El comprimido trae varios juegos (lo normal: la version normal y un backport) y PS5 Dump Forge
|
|
solo convierte uno. Descomprime en el PC solo el que toca y devuelve su carpeta (None si no se puede)."""
|
|
import subprocess
|
|
import shutil
|
|
exe7 = E.find_7z(cfg.get("sevenzip_path") or "")
|
|
if not exe7:
|
|
jlog(job, "Trae varias aplicaciones y para separarlas hace falta 7-Zip, que no está instalado")
|
|
return None
|
|
entries, pw = None, None
|
|
for c in cands:
|
|
try:
|
|
entries, _ = E.list_7z(exe7, archive, c)
|
|
pw = c
|
|
break
|
|
except E.PipeError as e:
|
|
if not E._pw_error(str(e)):
|
|
jlog(job, str(e))
|
|
return None
|
|
if entries is None:
|
|
return None
|
|
roots = sorted({e["path"][:-len("/sce_sys/param.json")] for e in entries
|
|
if e["path"].lower().endswith("/sce_sys/param.json")})
|
|
if not roots:
|
|
return None
|
|
normal = [r for r in roots if not _backport_label(r)]
|
|
root = normal[0] if normal else roots[0]
|
|
others = [r for r in roots if r != root]
|
|
total = sum(e["size"] for e in entries if e["path"] == root or e["path"].startswith(root + "/"))
|
|
jlog(job, "Trae %d aplicaciones (%s): PS5 Dump Forge solo convierte una, así que descomprimo en el PC solo "
|
|
"%s y convierto eso" % (len(roots), ", ".join(roots), root))
|
|
if others:
|
|
jlog(job, "Lo que no se usa: %s" % ", ".join(others))
|
|
work = os.path.join(pc_temp_root(cfg), "forge", job["id"], "origen")
|
|
folder = os.path.join(work, *root.split("/"))
|
|
if os.path.isfile(os.path.join(work, ".hecho")) and os.path.isfile(os.path.join(folder, "sce_sys", "param.json")):
|
|
jlog(job, "Ya estaba descomprimido en el PC: %s" % root)
|
|
return folder
|
|
shutil.rmtree(work, ignore_errors=True)
|
|
os.makedirs(work, exist_ok=True)
|
|
free_pc = shutil.disk_usage(work).free
|
|
if total * 2 + GiB > free_pc:
|
|
raise E.PipeError("No cabe en el PC: para separarlo y convertirlo hacen falta unos %s y en %s hay %s "
|
|
"libres. Libera espacio o elige «Sin convertir»." % (human(total * 2 + GiB), work,
|
|
human(free_pc)))
|
|
setj(job, status="convirtiendo", pc_step="convertir", phase="Descomprimiendo %s en el PC para convertirlo" % root,
|
|
conv_pct=0, conv_text="")
|
|
proc = subprocess.Popen(E._7z_cmd(exe7, "x", archive, "-o" + work, root, password=pw),
|
|
stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
|
|
creationflags=E._NOWIN)
|
|
while proc.poll() is None:
|
|
if cancel.is_set():
|
|
proc.kill()
|
|
raise E.Cancelled()
|
|
done = _dir_size(work) if os.path.isdir(work) else 0
|
|
if total:
|
|
pct = min(99, int(done * 100 / total))
|
|
setj(job, conv_pct=pct, conv_text="Descomprimiendo · %s de %s" % (human(done), human(total)),
|
|
phase="Descomprimiendo %s en el PC para convertirlo: %d%%" % (root, pct))
|
|
time.sleep(0.5)
|
|
if proc.returncode != 0:
|
|
err = proc.stderr.read().decode("utf-8", "replace").strip()
|
|
raise E.PipeError("7-Zip no pudo descomprimirlo para convertirlo: %s" % err[-300:])
|
|
if not os.path.isfile(os.path.join(folder, "sce_sys", "param.json")):
|
|
jlog(job, "No encuentro %s después de descomprimir" % root)
|
|
return None
|
|
open(os.path.join(work, ".hecho"), "w").close()
|
|
return folder
|
|
|
|
|
|
def forge_job(job, srcs, cfg, cancel, src_path, created, pc_folder, up):
|
|
"""Convierte con PS5 Dump Forge en el PC y envia el resultado. None = mejor como carpeta normal."""
|
|
import shutil
|
|
fmt = job_fmt(job)
|
|
exe = ensure_forge(job, cfg)
|
|
setj(job, status="convirtiendo", pc_step="convertir", phase="Analizando con PS5 Dump Forge",
|
|
conv_pct=0, conv_text="", speed_label="", sent_label="")
|
|
info, pw_ok = None, None
|
|
cands = [None] + password_candidates(job, cfg)
|
|
last = None
|
|
for pw in cands:
|
|
try:
|
|
info = F.forge_inspect(exe, src_path, pw, cancel)
|
|
pw_ok = pw
|
|
break
|
|
except E.PipeError as e:
|
|
last = e
|
|
low = str(e).lower()
|
|
if not any(w in low for w in ("password", "encrypt", "wrong", "contrase", "crc")):
|
|
break
|
|
if info is None and last and "more than one ps5 game" in str(last).lower() and os.path.isfile(src_path):
|
|
sub = forge_split_archive(job, cfg, cancel, src_path, cands)
|
|
if sub:
|
|
return forge_job(job, srcs, cfg, cancel, sub, created, pc_folder, up)
|
|
if info is None:
|
|
jlog(job, "PS5 Dump Forge no puede leerlo: %s" % last)
|
|
if not any(w in str(last).lower() for w in ("password", "encrypt")):
|
|
with LOCK:
|
|
job["warning"] = ("No se ha podido convertir (PS5 Dump Forge: %s). Se ha enviado sin convertir."
|
|
% str(last)[:160])
|
|
if last and any(w in str(last).lower() for w in ("password", "encrypt")):
|
|
raise E.PipeError("Ninguna contraseña abre el comprimido. Escríbela en el trabajo o en Ajustes y "
|
|
"pulsa Reintentar (no se vuelve a descargar).")
|
|
return None
|
|
tid = info.get("title_id") or E.title_id(srcs[0].name)
|
|
title = info.get("title_name")
|
|
need_fw = info.get("backport_firmware") or info.get("firmware")
|
|
remember_title(tid, title, need_fw, info.get("firmware"), info.get("cover"),
|
|
{"backport": bool(info.get("backport"))})
|
|
if title:
|
|
setj(job, title="%s (%s)" % (title, tid) if tid else title)
|
|
for line in (info.get("findings") or [])[:8]:
|
|
jlog(job, "Forge avisa: %s" % line)
|
|
if info.get("additional_content") and fmt != "plain":
|
|
jlog(job, "Es un DLC o una actualización: no se puede convertir a imagen")
|
|
return None
|
|
lz4 = info.get("lz4") or {}
|
|
extra = []
|
|
if fmt == "plain" and lz4.get("packed"):
|
|
extra.append("--lz4-unpack")
|
|
jlog(job, "Viene empaquetado en LZ4: lo desempaqueto a archivos normales")
|
|
if fmt == "fpkg":
|
|
mine = (SETTINGS.get("console_fw") or "").strip()
|
|
if mine and F.fw_ok(FPKG_MAX_FW, mine) is False:
|
|
raise E.PipeError("Los .fpkg solo funcionan con firmware %s o inferior y tu PS5 tiene %s. Elige "
|
|
"«Imagen .ffpkg» (o «Sin convertir») y pulsa Reintentar." % (FPKG_MAX_FW, mine))
|
|
jlog(job, "Ojo: los .fpkg solo se instalan en firmware %s o inferior (con kstuff, fpkg-enable y "
|
|
"ppr-patch)" % FPKG_MAX_FW)
|
|
comp = job.get("comp") or ("fast" if fmt == "fpkg" else "balanced")
|
|
if fmt in F.FORGE_COMP and comp in F.FORGE_COMP[fmt]:
|
|
extra += F.FORGE_COMP[fmt][comp]
|
|
jlog(job, "Compresión: %s" % {"fast": "rápida", "balanced": "equilibrada", "smallest": "mínimo tamaño",
|
|
"stored": "sin compresión"}[comp])
|
|
if fmt in ("lz4", "lz4ffpkg") and not lz4.get("imports_ampr"):
|
|
jlog(job, "Este título no usa AMPR, así que LZ4 no sirve con él")
|
|
if fmt == "lz4":
|
|
msg = ("PS5 Dump Forge dice que este título no usa AMPR, así que no se puede pasar a LZ4: "
|
|
"se envía sin convertir, como carpeta normal.")
|
|
with LOCK:
|
|
job["warning"] = msg
|
|
jlog(job, msg)
|
|
return None
|
|
fmt = "ffpkg"
|
|
with LOCK:
|
|
job["warning"] = ("PS5 Dump Forge dice que este título no usa AMPR: se envía como imagen .ffpkg "
|
|
"normal, sin LZ4.")
|
|
jlog(job, "Lo convierto a imagen .ffpkg normal")
|
|
setj(job, fmt_real=fmt)
|
|
if fmt in ("lz4", "lz4ffpkg"):
|
|
jlog(job, "LZ4 es experimental (ampr_emu de prueba): con algunos títulos se cuelga al guardar partida")
|
|
check_fw_warning(job, tid, title, need_fw, info.get("firmware"), bool(info.get("backport")))
|
|
bf = E.BFpilot(cfg)
|
|
dest = "/data/pkg" if fmt == "fpkg" else (job.get("dest") or cfg["dest"]).rstrip("/")
|
|
ext = F.FORGE_FORMATS[fmt][1]
|
|
base = tid or E.safe_name(E.display_name(srcs[0].name))[:50]
|
|
name = (base + ext) if ext else (base + "-app")
|
|
target = dest + "/" + name
|
|
check_duplicates_first(job, bf, tid, exclude=target)
|
|
total = int(info.get("total_bytes") or 0)
|
|
work = os.path.join(pc_temp_root(cfg), "forge", job["id"])
|
|
os.makedirs(work, exist_ok=True)
|
|
out = os.path.join(work, name)
|
|
marker = os.path.join(work, ".hecho-" + fmt)
|
|
if not (os.path.exists(out) and os.path.isfile(marker)):
|
|
free_pc = shutil.disk_usage(work).free
|
|
need_pc = int(total * 1.05) + GiB
|
|
if total and need_pc > free_pc:
|
|
raise E.PipeError("No cabe en el PC: la %s ocupará hasta %s y en %s hay %s libres. Libera espacio, "
|
|
"cambia la carpeta temporal en Ajustes o elige 'Carpeta normal'."
|
|
% (FMT_LABEL[fmt], human(need_pc), work, human(free_pc)))
|
|
free = free_space(bf) if bf.alive() else None
|
|
est = int(total * (0.5 if fmt in ("ffpfsc", "lz4", "lz4ffpkg") else 0.9 if fmt == "fpkg" else 1.02))
|
|
if free is not None and total and est + margin_bytes() > free:
|
|
raise no_space(job, est, free, "Lo más probable es que no quepa en la PS5: la %s ocupará unos %s, hay "
|
|
"%s libres y dejo %s de margen." % (FMT_LABEL[fmt], human(est), human(free),
|
|
human(margin_bytes())))
|
|
for p in (out, out + ".part"):
|
|
if os.path.isdir(p):
|
|
shutil.rmtree(p, ignore_errors=True)
|
|
elif os.path.exists(p):
|
|
os.remove(p)
|
|
jlog(job, "Convirtiendo a %s con PS5 Dump Forge (%s sin convertir)" % (FMT_LABEL[fmt], human(total)))
|
|
t0 = {"t": 0.0}
|
|
|
|
def prog(stage, done, tot):
|
|
now = time.time()
|
|
if now - t0["t"] < 0.4:
|
|
return
|
|
t0["t"] = now
|
|
pct = int(done * 100 / tot) if tot else 0
|
|
label = F.FORGE_STAGES.get(stage, stage)
|
|
setj(job, conv_pct=pct, conv_text="%s · %s de %s" % (label, human(done), human(tot) if tot else "?"),
|
|
phase="Convirtiendo a %s: %s %d%%" % (FMT_LABEL[fmt], label, pct))
|
|
F.forge_convert(exe, src_path, out, fmt, pw_ok, cancel, prog, lambda m: jlog(job, "Forge: " + m), extra)
|
|
with open(marker, "w") as fh:
|
|
fh.write("ok")
|
|
size = _dir_size(out) if os.path.isdir(out) else os.path.getsize(out)
|
|
jlog(job, "Listo en el PC: %s (%s)" % (name, human(size)))
|
|
if total and size:
|
|
jlog(job, "Ocupa %s frente a %s sin convertir" % (human(size), human(total)))
|
|
free = free_space(bf) if bf.alive() else None
|
|
if free is not None and size + margin_bytes() > free:
|
|
raise no_space(job, size, free, "No cabe en la PS5: la %s ocupa %s, hay %s libres y dejo %s de margen. "
|
|
"Libera espacio y pulsa Reintentar (no se vuelve a convertir)."
|
|
% (FMT_LABEL[fmt], human(size), human(free), human(margin_bytes())))
|
|
setj(job, status="enviando", pc_step="enviar", total=size, sent=0, conv_pct=100, conv_text="",
|
|
phase="Enviando %s" % name)
|
|
last = {"v": 0}
|
|
|
|
def progress(v, *_):
|
|
if v > last["v"]:
|
|
up(v - last["v"])
|
|
last["v"] = v
|
|
setj(job, sent=v, speed=up.rate())
|
|
if target.rstrip("/") not in set(job.get("own_paths") or []) and bf.alive() and bf.exists(target):
|
|
# en el destino ya hay algo con ese nombre que no es de este trabajo: no se mezcla con lo convertido
|
|
if os.path.isdir(out) and not bf.exists(target + "/sce_sys/param.json"):
|
|
jlog(job, "En %s había un envío anterior a medias: lo sustituyo" % target)
|
|
bf.delete(target, cancel)
|
|
else:
|
|
target = resolve_existing(job, target, bf.exists, lambda t: bf.delete(t, cancel), tid)
|
|
claim_target(job, target)
|
|
watch = start_space_watch(job, bf, cancel, "el envio")
|
|
try:
|
|
if os.path.isdir(out):
|
|
src = E.FolderSource(out).probe()
|
|
sent, skipped, resumed = E.upload_tree(cfg, src, target, cancel, lambda m: jlog(job, m),
|
|
lambda v, rel: progress(v))
|
|
jlog(job, "Carpeta enviada: %d archivos nuevos, %d ya estaban, %d continuados" % (sent, skipped, resumed))
|
|
if bf.alive():
|
|
fix_game_perms(job, bf, target, cancel)
|
|
else:
|
|
fs = E.FileSource(out).probe()
|
|
# se escribe como .ps5part y se renombra al final: ShadowMountPlus no ve una imagen a medias
|
|
E.upload(cfg, target, fs.size, lambda off: fs.stream(off, cfg, cancel, lambda n: None),
|
|
progress, cancel, lambda m: jlog(job, m))
|
|
finally:
|
|
watch.set()
|
|
setj(job, sent=size)
|
|
shutil.rmtree(work, ignore_errors=True)
|
|
if created and cfg.get("delete_archives", True):
|
|
for pth in created:
|
|
try:
|
|
os.remove(pth)
|
|
except OSError:
|
|
pass
|
|
try:
|
|
os.rmdir(pc_folder)
|
|
except OSError:
|
|
pass
|
|
jlog(job, "Borradas del PC las partes descargadas")
|
|
with LOCK:
|
|
job["_placed_game"] = True
|
|
return {"mode": "done", "placed": [target], "game": True}
|
|
|
|
|
|
def pc_temp_root(cfg):
|
|
d = (cfg.get("pc_temp_dir") or "").strip().strip('"')
|
|
return d or os.path.join(downloads_dir(), "PS5 Directo (temporal)")
|
|
|
|
|
|
def _pcx_state(job):
|
|
try:
|
|
with open(os.path.join(PCX_DIR, job["id"] + ".json"), encoding="utf-8") as f:
|
|
return json.load(f)
|
|
except Exception:
|
|
return {}
|
|
|
|
|
|
def _pcx_save(job, st):
|
|
try:
|
|
os.makedirs(PCX_DIR, exist_ok=True)
|
|
tmp = os.path.join(PCX_DIR, job["id"] + ".json.tmp")
|
|
with open(tmp, "w", encoding="utf-8") as f:
|
|
json.dump(st, f)
|
|
os.replace(tmp, os.path.join(PCX_DIR, job["id"] + ".json"))
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _pcx_forget(job):
|
|
try:
|
|
os.remove(os.path.join(PCX_DIR, job["id"] + ".json"))
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def fetch_to_pc(job, srcs, cfg, cancel, meter, folder):
|
|
"""Baja al PC las partes que son enlaces (las de tu PC se usan tal cual).
|
|
Devuelve {nombre: ruta local} y la lista de archivos que hemos creado nosotros."""
|
|
import shutil
|
|
local, created = {}, []
|
|
urls = [s for s in srcs if s.kind != "file"]
|
|
for s in srcs:
|
|
if s.kind == "file":
|
|
local[s.name] = s.path
|
|
if not urls:
|
|
return local, created
|
|
if any(s.size < 0 for s in urls):
|
|
raise E.PipeError("Para bajar al PC hace falta saber el tamano de cada parte")
|
|
os.makedirs(folder, exist_ok=True)
|
|
|
|
def have(s):
|
|
final = os.path.join(folder, s.name)
|
|
if os.path.isfile(final) and os.path.getsize(final) == s.size:
|
|
return s.size
|
|
part = final + ".part"
|
|
return min(os.path.getsize(part), s.size) if os.path.isfile(part) else 0
|
|
|
|
total = sum(s.size for s in urls)
|
|
missing = sum(s.size - have(s) for s in urls)
|
|
free = shutil.disk_usage(folder).free
|
|
if missing + 2 * GiB > free:
|
|
raise E.PipeError("No cabe en el PC: hay que bajar %s a %s y solo hay %s libres. Libera espacio, "
|
|
"cambia la carpeta temporal en Ajustes o descomprime en la PS5."
|
|
% (human(missing), folder, human(free)))
|
|
jlog(job, "Bajando %d partes al PC (%s) en %s" % (len(urls), human(total), folder))
|
|
done_before = 0
|
|
for k, s in enumerate(urls, 1):
|
|
final = os.path.join(folder, s.name)
|
|
created.append(final)
|
|
local[s.name] = final
|
|
if os.path.isfile(final) and os.path.getsize(final) == s.size:
|
|
done_before += s.size
|
|
setj(job, sent=done_before)
|
|
continue
|
|
part = final + ".part"
|
|
off = os.path.getsize(part) if os.path.isfile(part) else 0
|
|
if off > s.size:
|
|
off = 0
|
|
if off:
|
|
jlog(job, "%s: continuando desde %s" % (s.name, human(off)))
|
|
setj(job, phase="Bajando al PC: parte %d de %d (%s)" % (k, len(urls), s.name))
|
|
got = off
|
|
hasher = part_hasher(job, s)
|
|
if hasher is not None and off:
|
|
hasher.valid = False # continuacion de otra vez: no se puede sumar desde el principio
|
|
with open(part, "r+b" if off else "wb") as f:
|
|
f.seek(off)
|
|
f.truncate()
|
|
it = s.stream(off, cfg, cancel, meter)
|
|
for data in (hasher.wrap(it, off) if hasher else it):
|
|
f.write(data)
|
|
got += len(data)
|
|
setj(job, sent=done_before + got)
|
|
if got != s.size:
|
|
raise E.PipeError("La descarga de %s se quedo corta (%s de %s). Pulsa Reintentar."
|
|
% (s.name, human(got), human(s.size)))
|
|
verify_part(job, s, hasher, on_bad=lambda: os.remove(part))
|
|
os.replace(part, final)
|
|
done_before += s.size
|
|
jlog(job, "En el PC: %s" % s.name)
|
|
return local, created
|
|
|
|
|
|
def pc_extract_job(job, srcs, cancel):
|
|
cfg = cfg_snapshot()
|
|
cfg["_limit_bps"] = live_limit_bps
|
|
log = lambda m: jlog(job, m) # noqa: E731
|
|
names = [s.name for s in srcs]
|
|
tar = any(E.is_tar(n) for n in names)
|
|
exe = None if tar else E.find_7z(cfg.get("sevenzip_path"))
|
|
no7z = E.PipeError("Para descomprimir en el PC hace falta 7-Zip (gratis, 7-zip.org). Instalalo, "
|
|
"o pon la ruta de 7z.exe en Ajustes, o elige 'Descomprimir en la PS5'.")
|
|
if not tar and not exe and not job_fmt(job):
|
|
with LOCK:
|
|
job["_force_plain"] = True # si Forge tampoco puede, mas abajo sale el aviso de 7-Zip
|
|
jlog(job, "No encuentro 7-Zip: lo intento sacar a una carpeta con PS5 Dump Forge")
|
|
folder = os.path.join(pc_temp_root(cfg), E.safe_name(E.set_key(srcs[0].name)))
|
|
dl, up = Meter(), Meter()
|
|
phase = {"dl": True}
|
|
stop_speed = threading.Event()
|
|
|
|
def speed_loop():
|
|
while not stop_speed.wait(1):
|
|
if phase["dl"]:
|
|
setj(job, speed=dl.rate(), dl_speed=0.0)
|
|
else:
|
|
setj(job, speed=up.rate(), dl_speed=0.0)
|
|
threading.Thread(target=speed_loop, daemon=True).start()
|
|
bf = E.BFpilot(cfg)
|
|
watch = None
|
|
try:
|
|
# 1) Las partes tienen que estar en el PC (7-Zip necesita poder saltar de una a otra)
|
|
if any(s.kind != "file" for s in srcs):
|
|
setj(job, status="enviando", total=sum(max(0, s.size) for s in srcs), sent=0,
|
|
speed_label="Descarga al PC", sent_label="Bajado al PC", pc_step="bajar")
|
|
check_duplicates_first(job, bf, E.title_id(srcs[0].name))
|
|
local, created = fetch_to_pc(job, srcs, cfg, cancel, dl, folder)
|
|
first = local[E.first_volume(names)]
|
|
if job_fmt(job) and not tar:
|
|
phase["dl"] = False
|
|
res = forge_job(job, srcs, cfg, cancel, first, created, folder, up)
|
|
if res is not None:
|
|
return res
|
|
if not E.is_archive(first):
|
|
return send_local_as_is(job, cfg, first, cancel, up)
|
|
jlog(job, "Sigo con 7-Zip y lo mando como carpeta normal")
|
|
if not exe:
|
|
raise no7z
|
|
if tar:
|
|
phase["dl"] = False
|
|
return pc_tar_job(job, srcs, cfg, cancel, local[names[0]], created, folder, up)
|
|
|
|
# 2) Leer el indice (con contrasena si hace falta)
|
|
setj(job, phase="Leyendo el contenido del comprimido", speed_label="", sent_label="",
|
|
pc_step="enviar")
|
|
cands = password_candidates(job, cfg)
|
|
try:
|
|
entries, props = E.list_7z(exe, first)
|
|
list_pw = None
|
|
except E.PipeError as e:
|
|
if not E._pw_error(str(e)):
|
|
raise
|
|
entries = None
|
|
for pw in cands:
|
|
try:
|
|
entries, props = E.list_7z(exe, first, pw)
|
|
list_pw = pw
|
|
break
|
|
except E.PipeError:
|
|
continue
|
|
if entries is None:
|
|
raise E.PipeError("Ninguna contrasena abre el comprimido. Escribela en el trabajo o en "
|
|
"Ajustes y pulsa Reintentar (no se vuelve a descargar).")
|
|
files = [e for e in entries if not e["dir"]]
|
|
total = sum(e["size"] for e in files)
|
|
jlog(job, "Dentro hay %d archivos que ocupan %s descomprimidos%s"
|
|
% (len(files), human(total), " (solido)" if props.get("Solid") == "+" else ""))
|
|
if list_pw is not None:
|
|
pws = [list_pw]
|
|
elif E.needs_password(entries):
|
|
pws = cands
|
|
if not pws:
|
|
raise E.PipeError("El comprimido tiene contrasena. Escribela en el trabajo o en Ajustes "
|
|
"y pulsa Reintentar.")
|
|
else:
|
|
pws = [None]
|
|
|
|
# 3) Sitio en la PS5: ahora se sabe exacto lo que ocupara todo
|
|
staging = "%s/extract/%s" % (WORK_ROOT, job["id"])
|
|
sig = "%s|%d|%d" % (entries[0]["path"] if entries else "", len(entries), total)
|
|
st = _pcx_state(job)
|
|
skip = int(st.get("done") or 0) if st.get("sig") == sig else 0
|
|
if skip:
|
|
try:
|
|
if not bf.alive() or not bf.exists(staging):
|
|
skip = 0
|
|
except Exception:
|
|
skip = 0
|
|
already = sum(e["size"] for e in entries[:skip])
|
|
free = free_space(bf)
|
|
margin = margin_bytes()
|
|
if free is not None:
|
|
need = total - already
|
|
if need + margin > free:
|
|
raise no_space(job, need, free, "No cabe en la PS5: descomprimido ocupa %s, faltan por mandar %s, "
|
|
"hay %s libres y dejo %s de margen. Libera espacio y pulsa Reintentar."
|
|
% (human(total), human(need), human(free), human(margin)))
|
|
jlog(job, "Espacio libre en la PS5: %s (hacen falta %s)" % (human(free), human(need)))
|
|
watch = start_space_watch(job, bf, cancel, "el envio")
|
|
|
|
# 4) Descomprimir y mandar, archivo a archivo
|
|
phase["dl"] = False
|
|
setj(job, status="enviando", total=total, sent=already, pc_step="enviar",
|
|
phase="Descomprimiendo en el PC y enviando a la PS5")
|
|
ordinal = {}
|
|
for e in entries:
|
|
if not e["dir"]:
|
|
ordinal[e["path"]] = len(ordinal) + 1
|
|
if skip:
|
|
jlog(job, "Continuo donde iba: %s ya estaban en la PS5" % human(already))
|
|
last = {"v": already, "t": 0.0}
|
|
|
|
def progress(v, path):
|
|
if v > last["v"]:
|
|
up(v - last["v"])
|
|
last["v"] = v
|
|
now = time.time()
|
|
if now - last["t"] > 0.5:
|
|
last["t"] = now
|
|
name = path.rsplit("/", 1)[-1]
|
|
setj(job, sent=v, phase="Descomprimiendo en el PC y enviando: archivo %d de %d · %s"
|
|
% (ordinal.get(path, 0), len(ordinal), name[-60:]))
|
|
|
|
# Donde estan las aplicaciones dentro del comprimido (carpeta con sce_sys/param.json)
|
|
capture = {}
|
|
roots = []
|
|
for e in entries:
|
|
low = e["path"].lower()
|
|
if not e["dir"] and (low == "sce_sys/param.json" or low.endswith("/sce_sys/param.json")):
|
|
root = e["path"][:-len("sce_sys/param.json")].rstrip("/")
|
|
if not any(root == r or root.startswith(r + "/") for r in roots if r) and "" not in roots:
|
|
roots.append(root)
|
|
capture[e["path"]] = None
|
|
state = {"done": skip, "files": 0}
|
|
|
|
def on_file(n):
|
|
state["done"] = n
|
|
if not entries[n - 1]["dir"]:
|
|
state["files"] += 1
|
|
_pcx_save(job, {"sig": sig, "done": n})
|
|
|
|
for k, pw in enumerate(pws):
|
|
start = state["done"]
|
|
files_before = state["files"]
|
|
if pw:
|
|
jlog(job, "Probando contrasena %d de %d" % (k + 1, len(pws)))
|
|
try:
|
|
E.stream_extract_7z(exe, first, entries, pw, staging, cfg, cancel, log, progress,
|
|
on_file=on_file, skip=start, capture=capture)
|
|
if pw:
|
|
jlog(job, "Contrasena correcta")
|
|
break
|
|
except E.PipeError as e:
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
bad_pw = state["files"] == files_before and len(pws) > 1 and (
|
|
"contrasena" in str(e) or "CRC" in str(e))
|
|
if bad_pw and k + 1 < len(pws):
|
|
continue
|
|
if bad_pw:
|
|
raise E.PipeError("Ninguna contrasena ha funcionado. Escribela en el trabajo o en "
|
|
"Ajustes y pulsa Reintentar (no se vuelve a descargar).")
|
|
raise
|
|
setj(job, sent=total)
|
|
jlog(job, "Enviado ya descomprimido: %d archivos, %s, todos comprobados con su CRC"
|
|
% (len(files), human(total)))
|
|
games = []
|
|
for root in roots:
|
|
pj = (root + "/" if root else "") + "sce_sys/param.json"
|
|
raw = capture.get(pj) or b""
|
|
tid = (E.title_id(raw.decode("utf-8", "replace")) or E.title_id(root)
|
|
or E.title_id(srcs[0].name))
|
|
games.append({"root": root, "tid": tid})
|
|
return {"mode": "pcx", "staging": staging, "hint": E.display_name(srcs[0].name), "games": games,
|
|
"pc_files": created, "pc_folder": folder if created else ""}
|
|
finally:
|
|
stop_speed.set()
|
|
if watch:
|
|
watch.set()
|
|
setj(job, speed=0.0, dl_speed=0.0, speed_label="", sent_label="")
|
|
|
|
|
|
def ftp_place(job, info, dest, cfg):
|
|
"""Coloca lo enviado en modo PC solo con FTP (sin BFpilot): renombrar es instantaneo."""
|
|
staging = info["staging"]
|
|
hint = info.get("hint") or job["id"]
|
|
ftp = E.Ftp(cfg)
|
|
f = ftp.connect()
|
|
|
|
def is_dir(path):
|
|
try:
|
|
f.cwd(path)
|
|
f.cwd("/")
|
|
return True
|
|
except Exception:
|
|
return False
|
|
try:
|
|
if not is_dir(staging):
|
|
_pcx_forget(job)
|
|
raise E.PipeError("No encuentro en la PS5 lo enviado (%s). Pulsa Reintentar para mandarlo "
|
|
"de nuevo." % staging)
|
|
games = info.get("games") or []
|
|
mains = [g for g in games if not _backport_label(g.get("root") or "")]
|
|
if mains and len(mains) < len(games):
|
|
for g in games:
|
|
label = _backport_label(g.get("root") or "")
|
|
if not label:
|
|
continue
|
|
_, msg = _backport_msg(job, label, g.get("tid") or "?", None)
|
|
aside = "%s/backports/%s-%s" % (WORK_ROOT, g.get("tid") or "x", E.safe_name(label))
|
|
try:
|
|
E.Ftp.mkdirs(f, WORK_ROOT + "/backports")
|
|
f.rename(staging + "/" + g["root"], aside)
|
|
jlog(job, msg + " Lo dejo en %s." % aside)
|
|
except Exception as e:
|
|
jlog(job, "No pude apartar el backport (%s): %s" % (g["root"], e))
|
|
games = mains
|
|
moves = []
|
|
if games:
|
|
for g in games:
|
|
src = staging + ("/" + g["root"] if g["root"] else "")
|
|
name = (g["tid"] + "-app") if g.get("tid") else E.safe_name(
|
|
g["root"].rsplit("/", 1)[-1] if g["root"] else hint)
|
|
moves.append((src, dest + "/" + name))
|
|
else:
|
|
moves.append((staging, dest + "/" + E.safe_name(hint)))
|
|
placed = []
|
|
for src, target in moves:
|
|
if is_dir(target):
|
|
target = resolve_existing(job, target, is_dir, lambda t: ftp_rmtree(cfg, t, threading.Event()),
|
|
E.title_id(target))
|
|
E.Ftp.mkdirs(f, dest)
|
|
f.rename(src, target)
|
|
jlog(job, "Colocado: %s" % target)
|
|
placed.append(target)
|
|
job["_placed_game"] = bool(games)
|
|
# carpeta de trabajo vacia (si venia dentro de otra carpeta, quedan restos)
|
|
try:
|
|
f.rmd(staging)
|
|
except Exception:
|
|
if is_dir(staging):
|
|
jlog(job, "Quedan restos en %s (vacios). Puedes borrarlos con Limpieza." % staging)
|
|
return placed
|
|
finally:
|
|
try:
|
|
f.quit()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def pc_tar_job(job, srcs, cfg, cancel, path, created, folder, up):
|
|
""".tar / .tar.gz / .tar.bz2 / .tar.xz: se descomprime en el PC con Python (sin 7-Zip)."""
|
|
staging = "%s/extract/%s" % (WORK_ROOT, job["id"])
|
|
total = os.path.getsize(path)
|
|
sig = "tar|%s|%d" % (os.path.basename(path), total)
|
|
st = _pcx_state(job)
|
|
skip = int(st.get("done") or 0) if st.get("sig") == sig else 0
|
|
bf = E.BFpilot(cfg)
|
|
if skip:
|
|
try:
|
|
if not bf.alive() or not bf.exists(staging):
|
|
skip = 0
|
|
except Exception:
|
|
skip = 0
|
|
free = free_space(bf)
|
|
if free is not None:
|
|
jlog(job, "Espacio libre en la PS5: %s" % human(free))
|
|
if free < margin_bytes():
|
|
raise no_space(job, total, free,
|
|
"No hay sitio en la PS5: quedan %s libres y el margen es %s. Libera espacio "
|
|
"y pulsa Reintentar." % (human(free), human(margin_bytes())))
|
|
jlog(job, "Descomprimiendo el .tar en el PC y enviando a la PS5")
|
|
setj(job, status="enviando", total=total, sent=0, pc_step="enviar", sent_label="Leído del comprimido",
|
|
speed_label="Velocidad (comprimido)", phase="Descomprimiendo en el PC y enviando a la PS5")
|
|
last = {"v": 0, "t": 0.0}
|
|
|
|
def progress(v, tot, name):
|
|
if v > last["v"]:
|
|
up(v - last["v"])
|
|
last["v"] = v
|
|
now = time.time()
|
|
if now - last["t"] > 0.5:
|
|
last["t"] = now
|
|
setj(job, sent=v, phase="Descomprimiendo en el PC y enviando: %s" % name.rsplit("/", 1)[-1][-60:])
|
|
|
|
def on_file(n):
|
|
_pcx_save(job, {"sig": sig, "done": n})
|
|
watch = start_space_watch(job, bf, cancel, "el envio")
|
|
try:
|
|
nfiles, nbytes, params = E.stream_extract_tar(path, staging, cfg, cancel, lambda m: jlog(job, m),
|
|
progress, on_file, skip)
|
|
finally:
|
|
watch.set()
|
|
setj(job, sent=total)
|
|
jlog(job, "Enviado ya descomprimido: %d archivos, %s" % (nfiles, human(nbytes)))
|
|
games = []
|
|
for pj, raw in params.items():
|
|
root = pj[:-len("sce_sys/param.json")].rstrip("/")
|
|
if any(root == g["root"] or root.startswith(g["root"] + "/") for g in games if g["root"]):
|
|
continue
|
|
games.append({"root": root, "tid": E.title_id(raw.decode("utf-8", "replace")) or E.title_id(root)})
|
|
return {"mode": "pcx", "staging": staging, "hint": E.display_name(srcs[0].name), "games": games,
|
|
"pc_files": created, "pc_folder": folder if created else ""}
|
|
|
|
|
|
def finish_pc_extract(job, info, bf, dest, cancel, cfg):
|
|
staging = info["staging"]
|
|
setj(job, status="colocando", phase="Colocando en su sitio")
|
|
if not bf.alive():
|
|
jlog(job, "BFpilot no esta cargado: lo coloco por FTP")
|
|
placed = ftp_place(job, info, dest, cfg)
|
|
else:
|
|
if not bf.exists(staging):
|
|
_pcx_forget(job)
|
|
raise E.PipeError("No encuentro en la PS5 lo enviado (%s). Pulsa Reintentar para mandarlo "
|
|
"de nuevo." % staging)
|
|
placed = place(job, bf, staging, dest, cancel, info.get("hint") or job["id"])
|
|
for target in placed:
|
|
fix_game_perms(job, bf, target, cancel)
|
|
if bf.exists(staging):
|
|
try:
|
|
bf.delete(staging, cancel)
|
|
except Exception as e:
|
|
jlog(job, "No pude borrar %s: %s" % (staging, e))
|
|
_pcx_forget(job)
|
|
pc_files = info.get("pc_files") or []
|
|
if pc_files and cfg.get("delete_archives", True):
|
|
for pth in pc_files:
|
|
try:
|
|
os.remove(pth)
|
|
except Exception:
|
|
pass
|
|
try:
|
|
os.rmdir(info.get("pc_folder") or "")
|
|
except Exception:
|
|
pass
|
|
jlog(job, "Borradas del PC las partes descargadas")
|
|
elif pc_files:
|
|
jlog(job, "Las partes descargadas se quedan en %s" % info.get("pc_folder"))
|
|
return placed
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Fase 3: extraer en la PS5 y colocar el resultado
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def wait_bfpilot(job, bf, cancel):
|
|
first = True
|
|
while True:
|
|
v = bf.alive()
|
|
if v:
|
|
return v
|
|
if first:
|
|
jlog(job, "BFpilot no responde. Cargalo en la PS5 desde Payload Manager; sigo esperando.")
|
|
first = False
|
|
setj(job, phase="Esperando a BFpilot (cargalo desde Payload Manager)")
|
|
if cancel.wait(10):
|
|
raise E.Cancelled()
|
|
|
|
|
|
def find_payloads(bf, root, depth=4):
|
|
"""Busca aplicaciones (carpetas con sce_sys), imagenes y pkg dentro de lo extraido."""
|
|
found = []
|
|
|
|
def walk(path, d):
|
|
entries = bf.listdir(path)
|
|
names = {e["name"]: e for e in entries}
|
|
if "sce_sys" in names and names["sce_sys"].get("dir"):
|
|
sub = {e["name"] for e in bf.listdir(path + "/sce_sys")}
|
|
if "param.json" in sub or "param.sfo" in sub:
|
|
found.append(("game", path))
|
|
return
|
|
for e in entries:
|
|
full = path + "/" + e["name"]
|
|
low = e["name"].lower()
|
|
if e.get("dir"):
|
|
if d < depth and not low.startswith(".bfpilot-extracting"):
|
|
walk(full, d + 1)
|
|
elif low.endswith(E.IMAGE_EXTS):
|
|
found.append(("image", full))
|
|
elif low.endswith(".pkg"):
|
|
found.append(("pkg", full))
|
|
|
|
walk(root, 0)
|
|
return found
|
|
|
|
|
|
def game_bases(bf):
|
|
"""Carpetas que escanea ShadowMountPlus: interno + USB/externos montados."""
|
|
bases = ["/data/homebrew"]
|
|
pl = bf.places() or {}
|
|
for m in (pl.get("mounts") or []) + (pl.get("places") or []):
|
|
path = (m.get("path") or "").rstrip("/")
|
|
if re.match(r"^/mnt/(usb|ext)\d+$", path):
|
|
for b in (path + "/homebrew", path):
|
|
if b not in bases:
|
|
bases.append(b)
|
|
return bases
|
|
|
|
|
|
def fix_all_perms():
|
|
"""Repasa las aplicaciones en carpeta de /data/homebrew (y USB) y les pone permisos 777."""
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
if not bf.alive():
|
|
raise E.PipeError("Hace falta BFpilot cargado para revisar los permisos")
|
|
out = []
|
|
for base in game_bases(bf):
|
|
try:
|
|
ents = bf.listdir(base)
|
|
except Exception:
|
|
continue
|
|
for e in ents:
|
|
if not e.get("dir"):
|
|
continue
|
|
path = base + "/" + e["name"]
|
|
try:
|
|
changed, seen, notable = bf.fix_perms(path)
|
|
out.append({"path": path, "changed": changed, "seen": seen + 1,
|
|
"eboot": ["%o" % v for v in notable.values()][:1]})
|
|
except Exception as ex:
|
|
out.append({"path": path, "error": str(ex)})
|
|
return out
|
|
|
|
|
|
def find_duplicates(bf, tid, exclude=None):
|
|
"""Rutas que ya contienen ese Title ID (carpetas o imagenes)."""
|
|
if not tid:
|
|
return []
|
|
out = []
|
|
for base in game_bases(bf):
|
|
try:
|
|
entries = bf.listdir(base)
|
|
except Exception:
|
|
continue
|
|
for e in entries:
|
|
if tid.upper() in e["name"].upper():
|
|
p = "%s/%s" % (base, e["name"])
|
|
if p != exclude:
|
|
out.append(p)
|
|
return out
|
|
|
|
|
|
class NeedsDecision(Exception):
|
|
"""El trabajo se para a preguntar algo (por ejemplo, que hacer con una copia que ya existe)."""
|
|
|
|
|
|
def ftp_find_duplicates(cfg, tid, exclude=None):
|
|
"""Como find_duplicates pero solo con FTP (sin BFpilot): mira /data/homebrew y los USB."""
|
|
out = []
|
|
|
|
def go(f):
|
|
for base in ["/data/homebrew"] + ["/mnt/usb%d/homebrew" % i for i in range(4)] + \
|
|
["/mnt/ext%d/homebrew" % i for i in range(2)]:
|
|
try:
|
|
ents = E.ftp_listdir(f, base)
|
|
except ftplib.all_errors:
|
|
continue
|
|
for n, _ in ents:
|
|
if tid.upper() in n.upper() and not n.endswith(".ps5part"):
|
|
p = "%s/%s" % (base, n)
|
|
if p != exclude:
|
|
out.append(p)
|
|
E.Ftp(cfg).call(go)
|
|
return out
|
|
|
|
|
|
def check_duplicates_first(job, bf, tid, exclude=None):
|
|
"""Antes de enviar: si ese juego ya esta en la consola, pregunta que hacer (una vez).
|
|
Respuestas (job["dup_choice"]): send = enviar igualmente, replace = borrar la copia y enviar."""
|
|
if not tid:
|
|
return
|
|
cfg = cfg_snapshot()
|
|
try:
|
|
dups = find_duplicates(bf, tid, exclude) if bf.alive() else ftp_find_duplicates(cfg, tid, exclude)
|
|
except Exception:
|
|
return
|
|
own = set(job.get("own_paths") or [])
|
|
# lo que este mismo trabajo ya empezo a enviar (por ejemplo, al reanudar) no es una copia repetida
|
|
dups = [d for d in dups if not d.endswith(".ps5part") and d.rstrip("/") not in own]
|
|
if not dups:
|
|
return
|
|
choice = job.get("dup_choice")
|
|
if choice == "replace":
|
|
for p in dups:
|
|
setj(job, phase="Borrando la copia anterior: %s" % p)
|
|
jlog(job, "Borro la copia que ya habia: %s" % p)
|
|
if bf.alive():
|
|
bf.delete(p)
|
|
else:
|
|
ftp_rmtree(cfg, p, threading.Event())
|
|
with LOCK:
|
|
job["dup_choice"] = "send"
|
|
return
|
|
if choice == "send" or not cfg.get("dup_check", True):
|
|
msg = ("Ojo: ya tienes %s en %s. Dos copias con el mismo Title ID pueden liar a "
|
|
"ShadowMountPlus (deja solo una)." % (tid, ", ".join(dups[:4])))
|
|
jlog(job, msg)
|
|
with LOCK:
|
|
job["warning"] = msg
|
|
return
|
|
with LOCK:
|
|
job["ask"] = {"kind": "dup", "tid": tid, "paths": dups[:8]}
|
|
jlog(job, "%s ya esta en la consola (%s): espero a que elijas" % (tid, ", ".join(dups[:4])))
|
|
raise NeedsDecision()
|
|
|
|
|
|
def claim_target(job, target):
|
|
"""Apunta que este trabajo escribe en `target`, para no confundirlo con una copia repetida al reanudar."""
|
|
with LOCK:
|
|
own = job.setdefault("own_paths", [])
|
|
if target not in own:
|
|
own.append(target.rstrip("/"))
|
|
save_jobs()
|
|
|
|
|
|
def no_space(job, need, free, msg):
|
|
"""Error de falta de sitio, guardando cuanto habria que liberar (boton "Hacer sitio")."""
|
|
with LOCK:
|
|
job["need_bytes"] = int(max(0, need + margin_bytes() - (free or 0)))
|
|
return E.PipeError(msg)
|
|
|
|
|
|
def warn_duplicates(job, bf, tid, exclude=None, when=""):
|
|
try:
|
|
dups = find_duplicates(bf, tid, exclude)
|
|
except Exception:
|
|
return
|
|
if dups:
|
|
msg = ("Ojo: ya tienes %s en %s. Dos copias con el mismo Title ID pueden liar a "
|
|
"ShadowMountPlus (deja solo una)." % (tid, ", ".join(dups[:4])))
|
|
jlog(job, msg + when)
|
|
with LOCK:
|
|
job["warning"] = msg
|
|
|
|
|
|
def resolve_existing(job, target, exists, delete, tid=None):
|
|
"""Al colocar, si en el destino ya hay algo con ese nombre: lo decide el usuario (una vez).
|
|
Reemplazar = se borra lo que habia; Enviar igualmente = se coloca al lado con otro nombre.
|
|
Devuelve el nombre final, o lanza NeedsDecision para que el trabajo se pare a preguntar."""
|
|
choice = job.get("dup_choice")
|
|
if choice == "replace":
|
|
jlog(job, "Borro la copia que ya había en %s" % target)
|
|
setj(job, phase="Borrando la copia anterior: %s" % target)
|
|
delete(target)
|
|
return target
|
|
if choice == "send":
|
|
k = 2
|
|
while exists("%s-%d" % (target, k)):
|
|
k += 1
|
|
alt = "%s-%d" % (target, k)
|
|
msg = ("Ya tenías %s: esta copia queda como %s. Dos copias con el mismo Title ID pueden liar a "
|
|
"ShadowMountPlus (deja solo una)." % (target, alt))
|
|
jlog(job, msg)
|
|
with LOCK:
|
|
job["warning"] = msg
|
|
return alt
|
|
with LOCK:
|
|
job["ask"] = {"kind": "dup", "tid": tid or posixpath.basename(target), "paths": [target], "at": "place"}
|
|
jlog(job, "Ya existe %s: espero a que elijas" % target)
|
|
raise NeedsDecision()
|
|
|
|
|
|
def _backport_label(rel):
|
|
"""'backport (4.xx)' si alguna carpeta de la ruta se llama asi; None si no."""
|
|
for seg in rel.strip("/").split("/"):
|
|
if "backport" in seg.lower():
|
|
return seg
|
|
return None
|
|
|
|
|
|
def _backport_msg(job, label, tid, need_fw):
|
|
mine = (SETTINGS.get("console_fw") or "").strip()
|
|
ok = F.fw_ok(mine, need_fw) if mine and need_fw else None
|
|
if ok:
|
|
return ok, ("El comprimido trae también un %s de %s para firmwares más bajos. Tu PS5 (%s) puede abrir "
|
|
"la versión normal, así que coloco esa y no el backport." % (label, tid, mine))
|
|
return ok, ("El comprimido trae la versión normal de %s y un %s. Coloco la normal; el backport lo dejo aparte "
|
|
"por si tu firmware lo necesita." % (tid, label))
|
|
|
|
|
|
def split_backports(job, bf, found, staging):
|
|
"""Si lo extraido trae la aplicacion normal y ademas un 'backport' con el mismo Title ID, solo se coloca la
|
|
normal (antes salian las dos con el mismo nombre y la segunda daba 'Ya existe'). El backport se aparta."""
|
|
games = [p for k, p in found if k == "game"]
|
|
mains = [p for p in games if not _backport_label(p[len(staging):])]
|
|
bps = [p for p in games if _backport_label(p[len(staging):])]
|
|
if not mains or not bps:
|
|
return found
|
|
try:
|
|
facts = F.param_facts(bf.read_text(mains[0] + "/sce_sys/param.json"))
|
|
except Exception:
|
|
facts = {}
|
|
tid = facts.get("tid") or E.title_id(mains[0]) or "?"
|
|
for bp in bps:
|
|
label = _backport_label(bp[len(staging):])
|
|
ok, msg = _backport_msg(job, label, tid, facts.get("fw_param"))
|
|
jlog(job, msg)
|
|
if ok:
|
|
try:
|
|
bf.delete(bp)
|
|
except Exception:
|
|
pass
|
|
else:
|
|
aside = "%s/backports/%s-%s" % (WORK_ROOT, tid, E.safe_name(label))
|
|
try:
|
|
bf.mkdir(WORK_ROOT + "/backports")
|
|
if bf.exists(aside):
|
|
bf.delete(aside)
|
|
bf.rename(bp, aside)
|
|
jlog(job, "Backport apartado en %s: si tu firmware lo necesita, copia su contenido encima de la "
|
|
"carpeta de la aplicación." % aside)
|
|
except Exception as e:
|
|
jlog(job, "No pude apartar el backport (%s): %s" % (bp, e))
|
|
return [(k, p) for k, p in found if not (k == "game" and p in bps)]
|
|
|
|
|
|
def place(job, bf, staging, dest, cancel, hint_name):
|
|
found = find_payloads(bf, staging)
|
|
placed = []
|
|
found = split_backports(job, bf, found, staging)
|
|
if not found:
|
|
jlog(job, "No encontre sce_sys ni imagenes: dejo todo junto en una carpeta")
|
|
found = [("folder", staging)]
|
|
for kind, path in found:
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
name = posixpath.basename(path)
|
|
if kind == "game":
|
|
# Siempre TITLEID-app, venga suelto o dentro de una carpeta del RAR
|
|
tid = (E.title_id(bf.read_text(path + "/sce_sys/param.json"))
|
|
or E.title_id(name) or E.title_id(hint_name))
|
|
if tid:
|
|
name = tid + "-app"
|
|
elif path == staging:
|
|
name = E.safe_name(hint_name)
|
|
elif path == staging:
|
|
name = E.safe_name(hint_name)
|
|
target_dir = "/data/pkg" if kind == "pkg" else dest
|
|
target = target_dir + "/" + name
|
|
if kind in ("game", "image"):
|
|
warn_duplicates(job, bf, E.title_id(name), exclude=target)
|
|
if bf.exists(target) and kind == "game" and not bf.exists(target + "/sce_sys/param.json"):
|
|
# resto de un envio anterior que se quedo a medias: no es una aplicacion, se sustituye
|
|
jlog(job, "En %s había un envío anterior a medias: lo sustituyo" % target)
|
|
bf.delete(target, cancel)
|
|
if bf.exists(target):
|
|
target = resolve_existing(job, target, bf.exists, lambda t: bf.delete(t, cancel), E.title_id(name))
|
|
bf.mkdir(target_dir)
|
|
bf.rename(path, target)
|
|
jlog(job, "Colocado: %s" % target)
|
|
placed.append(target)
|
|
if kind in ("game", "image"):
|
|
job["_placed_game"] = True
|
|
return placed
|
|
|
|
|
|
def fix_game_perms(job, bf, target, cancel=None):
|
|
"""Tras descomprimir con BFpilot: permisos 777 (si no, la PS5 no la arranca)."""
|
|
try:
|
|
if not bf.exists(target):
|
|
return
|
|
setj(job, phase="Arreglando permisos de %s" % posixpath.basename(target))
|
|
changed, seen, notable = bf.fix_perms(target, cancel, log=lambda m: jlog(job, m))
|
|
old = ", ".join("%s tenia %o" % (k, v) for k, v in list(notable.items())[:2])
|
|
if changed:
|
|
jlog(job, "Permisos arreglados (777) en %d de %d elementos%s" % (changed, seen + 1,
|
|
(": " + old) if old else ""))
|
|
else:
|
|
jlog(job, "Permisos ya correctos")
|
|
except E.Cancelled:
|
|
raise
|
|
except Exception as e:
|
|
jlog(job, "AVISO: no pude poner los permisos de %s (%s). Si no arranca, en FileZilla: "
|
|
"clic derecho en la carpeta > Permisos > 777 > recurrir a subdirectorios." % (target, e))
|
|
|
|
|
|
def password_candidates(job, cfg):
|
|
cands = []
|
|
for p in ([job.get("password")] + list(cfg.get("passwords") or [])):
|
|
if p and p not in cands:
|
|
cands.append(p)
|
|
if cfg.get("guess_passwords", True):
|
|
for p in E.password_guesses([s["name"] for s in job["sources"]]):
|
|
if p not in cands:
|
|
cands.append(p)
|
|
return cands
|
|
|
|
|
|
def extract_job(job, info, cancel):
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
watch = start_space_watch(job, bf, cancel, "la descompresion")
|
|
try:
|
|
return _extract_job(job, info, cancel)
|
|
finally:
|
|
watch.set()
|
|
|
|
|
|
def _extract_job(job, info, cancel):
|
|
cfg = cfg_snapshot()
|
|
bf = E.BFpilot(cfg)
|
|
dest = job["dest"] or cfg["dest"]
|
|
if info["mode"] == "done":
|
|
for p in info.get("placed") or []:
|
|
jlog(job, "Colocado: %s" % p)
|
|
job["_placed_game"] = bool(info.get("game"))
|
|
return info.get("placed") or []
|
|
if info["mode"] == "pcx":
|
|
return finish_pc_extract(job, info, bf, dest, cancel, cfg)
|
|
staging = "%s/extract/%s" % (WORK_ROOT, job["id"])
|
|
|
|
if info["mode"] == "file" and not bf.alive():
|
|
# sin BFpilot: renombrar por FTP es instantaneo (mismo disco)
|
|
name = info["name"]
|
|
low = name.lower()
|
|
target_dir = "/data/pkg" if low.endswith(".pkg") else dest
|
|
target = target_dir + "/" + name
|
|
box = {"target": target}
|
|
|
|
def go(f):
|
|
try:
|
|
E.ftp_listdir(f, target_dir)
|
|
except ftplib.error_perm:
|
|
E.Ftp.mkdirs(f, target_dir)
|
|
if E.Ftp.size(f, target) is not None:
|
|
base, ext = os.path.splitext(target)
|
|
|
|
def ftp_del(t):
|
|
f.delete(t)
|
|
t2 = resolve_existing(job, base, lambda t: E.Ftp.size(f, t + ext) is not None,
|
|
lambda t: ftp_del(t + ext), E.title_id(name))
|
|
box["target"] = t2 + ext
|
|
f.rename(info["path"], box["target"])
|
|
try:
|
|
f.rmd(info["path"].rsplit("/", 1)[0])
|
|
except ftplib.all_errors:
|
|
pass
|
|
E.Ftp(cfg).call(go)
|
|
target = box["target"]
|
|
jlog(job, "Colocado: %s" % target)
|
|
if low.endswith(E.IMAGE_EXTS):
|
|
job["_placed_game"] = True
|
|
return [target]
|
|
|
|
wait_bfpilot(job, bf, cancel)
|
|
if info["mode"] == "file":
|
|
name = info["name"]
|
|
low = name.lower()
|
|
target_dir = "/data/pkg" if low.endswith(".pkg") else dest
|
|
target = target_dir + "/" + name
|
|
if bf.exists(target):
|
|
base, ext = os.path.splitext(target)
|
|
target = resolve_existing(job, base, lambda t: bf.exists(t + ext), lambda t: bf.delete(t + ext, cancel),
|
|
E.title_id(name)) + ext
|
|
bf.mkdir(target_dir)
|
|
bf.rename(info["path"], target)
|
|
jlog(job, "Colocado: %s" % target)
|
|
try:
|
|
bf.delete(info["path"].rsplit("/", 1)[0], cancel)
|
|
except Exception:
|
|
pass
|
|
if low.endswith(".pkg"):
|
|
jlog(job, "Es un .pkg: instalalo con ps5upload (Install Package) desde /data/pkg.")
|
|
return [target]
|
|
|
|
src = info["dir"] + "/" + info["first"]
|
|
cands = password_candidates(job, cfg) + [""]
|
|
bf.mkdir(WORK_ROOT + "/extract")
|
|
if bf.exists(staging):
|
|
# BFpilot solo crea esta carpeta cuando la extraccion termina bien
|
|
jlog(job, "Ya estaba descomprimido de antes; paso a colocarlo")
|
|
cands = []
|
|
else:
|
|
for e in bf.listdir(WORK_ROOT + "/extract"):
|
|
if e["name"].startswith(job["id"] + ".bfpilot-extracting"):
|
|
jlog(job, "Borrando restos de un intento anterior: %s" % e["name"])
|
|
bf.delete(WORK_ROOT + "/extract/" + e["name"], cancel)
|
|
|
|
live = {"sig": None, "t": time.time(), "warned": False}
|
|
guard = {"t": 0.0}
|
|
|
|
def check_runaway(st):
|
|
"""Mide cuanto lleva escrito BFpilot y cuanto queda libre, para avisar a tiempo."""
|
|
total = int(st.get("totalBytes") or 0)
|
|
if total <= 0 or time.time() - guard["t"] < 10:
|
|
return
|
|
guard["t"] = time.time()
|
|
try:
|
|
# Solo la carpeta temporal de ESTA descompresion (BFpilot la dice en "stage").
|
|
# Antes se sumaban restos de intentos anteriores y saltaba en falso.
|
|
stage = st.get("stage") or ""
|
|
if not stage.startswith(WORK_ROOT + "/extract/") or ".bfpilot-extracting" not in stage:
|
|
return
|
|
size = bf.du(stage) or 0
|
|
free = free_space(bf)
|
|
guard["size"], guard["free"] = size, free
|
|
# Prevision: el progreso de BFpilot cuenta lo LEIDO del RAR, no lo escrito. Un volcado en
|
|
# carpeta va sin comprimir y puede ocupar varias veces el RAR (visto: 35 GB -> 145 GB).
|
|
# Regla prudente: hasta ~5 veces lo que ocupa el RAR.
|
|
guard["fits"] = None
|
|
if free is not None:
|
|
worst = total * 5
|
|
guard["final"] = max(worst, size)
|
|
# lo que aun puede crecer (al menos 10 GB de colchon aunque ya pase del estimado)
|
|
guard["fits"] = (free - margin_bytes()) > max(worst - size, 10 * GiB)
|
|
except Exception:
|
|
pass
|
|
|
|
def on_status(st):
|
|
pct = int(st.get("percent") or 0)
|
|
txt = []
|
|
if st.get("totalBytes"):
|
|
# OJO: BFpilot cuenta lo LEIDO del RAR, no el tamano final (que puede ser mucho mayor)
|
|
txt.append("leído del comprimido %s de %s" % (human(st.get("bytesWritten") or 0), human(st["totalBytes"])))
|
|
if st.get("averageMBps"):
|
|
txt.append("%.0f MB/s" % float(st["averageMBps"]))
|
|
# Senal de vida: el porcentaje a veces solo sube al acabar cada archivo grande,
|
|
# pero lo leido/escrito y la CPU de BFpilot cambian aunque el % no se mueva.
|
|
sig = (st.get("bytesWritten"), st.get("inputBytes"), st.get("outputBytes"),
|
|
st.get("cpuTotalMs"), st.get("filesDone"), st.get("current"))
|
|
now = time.time()
|
|
if sig != live["sig"]:
|
|
live.update(sig=sig, t=now)
|
|
if live["warned"]:
|
|
jlog(job, "La descompresion vuelve a avanzar")
|
|
live["warned"] = False
|
|
if guard.get("size") is not None:
|
|
t = "descomprimido %s" % human(guard["size"])
|
|
if guard.get("free") is not None:
|
|
t += " · libre %s" % human(guard["free"])
|
|
if guard.get("fits") is False:
|
|
t += " · justo de espacio (en el peor caso podria llegar a ~%s)" % human(guard.get("final", 0))
|
|
elif guard.get("fits"):
|
|
t += " · hay sitio de sobra"
|
|
txt.append(t)
|
|
idle = now - live["t"]
|
|
if st.get("cpuUtilPercent") is not None and idle < 30:
|
|
txt.append("CPU %d%%" % float(st["cpuUtilPercent"]))
|
|
if idle >= 300:
|
|
txt.append("sin cambios desde hace %d min" % (idle // 60))
|
|
if not live["warned"]:
|
|
jlog(job, "Aviso: la descompresion no da senales de vida desde hace 5 min. "
|
|
"Mira en BFpilot (puerto 5905) si sigue 'running' antes de cancelar.")
|
|
live["warned"] = True
|
|
elif st.get("current"):
|
|
txt.append(str(st["current"])[-60:])
|
|
setj(job, extract_pct=pct, extract_text=" · ".join(txt))
|
|
check_runaway(st)
|
|
if guard.get("fits") is False and not guard.get("fit_logged"):
|
|
guard["fit_logged"] = True
|
|
jlog(job, "Aviso: lo descomprimido puede ocupar hasta ~5 veces el RAR (~%s) y quedan %s "
|
|
"libres. Puede bastar, pero si el espacio baja del margen lo paro. Si puedes, "
|
|
"libera espacio." % (human(guard.get("final", 0)), human(guard.get("free") or 0)))
|
|
|
|
last_err = None
|
|
final_st = None
|
|
for i, pw in enumerate(cands):
|
|
label = ("contraseña %d de %d" % (i + 1, len(cands) - 1)) if pw else "sin contraseña"
|
|
setj(job, status="extrayendo", phase="Descomprimiendo en la PS5 (%s)" % label,
|
|
extract_pct=0, extract_text="")
|
|
jlog(job, "Descomprimiendo %s (%s)" % (info["first"], label))
|
|
try:
|
|
final_st = bf.extract(src, staging, pw, cancel, on_status,
|
|
threads=cfg_snapshot().get("extract_threads", 0))
|
|
if pw:
|
|
jlog(job, "Contrasena correcta")
|
|
last_err = None
|
|
break
|
|
except E.PipeError as e:
|
|
last_err = e
|
|
jlog(job, "Fallo: %s" % e)
|
|
if bf.exists(staging):
|
|
bf.delete(staging, cancel)
|
|
if not E.is_password_error(str(e)):
|
|
break
|
|
if last_err is not None:
|
|
msg = str(last_err).lower()
|
|
if "aes" in msg:
|
|
raise E.PipeError("Este ZIP usa cifrado AES y BFpilot todavia no sabe abrirlo (solo el cifrado "
|
|
"ZIP clasico). Los archivos ya estan en la PS5, en %s. Puedes bajarlos al PC, "
|
|
"extraerlos con 7-Zip y subir la carpeta." % info["dir"])
|
|
if "unsupported archive type" in msg and re.search(r"\.z\d{2}$|\.zip$", info["first"], re.I):
|
|
raise E.PipeError("BFpilot no abre ZIP partidos (.z01, .z02...). Uno los RAR/7z partidos, "
|
|
"pero este formato no. Los archivos estan en %s." % info["dir"])
|
|
if E.is_password_error(str(last_err)):
|
|
raise E.PipeError("Ninguna contrasena ha funcionado. Escribela en el trabajo o en Ajustes "
|
|
"y pulsa Reintentar (no hace falta volver a descargar).")
|
|
raise last_err
|
|
|
|
got = bf.du(staging)
|
|
if got is not None:
|
|
jlog(job, "Lo descomprimido ocupa %s" % human(got))
|
|
|
|
setj(job, status="colocando", phase="Colocando en su sitio", extract_pct=100)
|
|
hint = info["first"][:len(E.set_key(info["first"]))] # mismo nombre, sin cambiar mayusculas
|
|
placed = place(job, bf, staging, dest, cancel, hint)
|
|
for target in placed:
|
|
fix_game_perms(job, bf, target, cancel)
|
|
for leftover in (staging,):
|
|
if bf.exists(leftover):
|
|
try:
|
|
bf.delete(leftover, cancel)
|
|
except Exception as e:
|
|
jlog(job, "No pude borrar %s: %s" % (leftover, e))
|
|
if cfg.get("delete_archives", True):
|
|
jlog(job, "Borrando los comprimidos de la PS5")
|
|
try:
|
|
bf.delete(info["dir"], cancel)
|
|
except Exception as e:
|
|
jlog(job, "No pude borrar %s: %s" % (info["dir"], e))
|
|
else:
|
|
jlog(job, "Los comprimidos se quedan en %s" % info["dir"])
|
|
return placed
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Hilos de trabajo: uno envia, otro descomprime (pueden ir a la vez)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def stopped(job):
|
|
"""Un trabajo se ha parado: por falta de espacio, por pausa o porque lo cancelaste."""
|
|
with LOCK:
|
|
reason = job.pop("_stop", None)
|
|
paused = job.pop("_pause", False)
|
|
if reason:
|
|
setj(job, status="error", error=reason, phase="Error")
|
|
jlog(job, "ERROR: %s" % reason)
|
|
elif paused:
|
|
setj(job, status="pausado", phase="En pausa (pulsa Reanudar para seguir)")
|
|
jlog(job, "En pausa")
|
|
else:
|
|
setj(job, status="cancelado", phase="Cancelado")
|
|
|
|
|
|
def sched_wait():
|
|
"""Segundos que faltan para la hora programada (0 = se puede empezar)."""
|
|
with LOCK:
|
|
t = float(SCHED.get("start") or 0)
|
|
if not t:
|
|
return 0
|
|
left = t - time.time()
|
|
if left <= 0:
|
|
with LOCK:
|
|
SCHED["start"] = 0
|
|
notify("info", "Empieza la cola programada")
|
|
return 0
|
|
return left
|
|
|
|
|
|
def transfer_worker():
|
|
while True:
|
|
with WAKE:
|
|
job = None
|
|
while job is None:
|
|
hold = sched_wait()
|
|
if hold > 0:
|
|
WAKE.wait(min(hold, 30))
|
|
continue
|
|
for j in JOBS:
|
|
if j["status"] == "pendiente":
|
|
job = j
|
|
break
|
|
if job is None:
|
|
WAKE.wait()
|
|
cancel = CANCELS.setdefault(job["id"], threading.Event())
|
|
cancel.clear()
|
|
job["status"] = "comprobando"
|
|
try:
|
|
if any(is_torrent(x) for x in job["lines"]):
|
|
torrent_stage(job, cfg_snapshot(), cancel)
|
|
srcs = probe_job(job, cancel)
|
|
sets = split_into_sets(srcs)
|
|
if len(sets) > 1:
|
|
jlog(job, "Detectados %d archivos distintos: los separo en varios trabajos" % len(sets))
|
|
with LOCK:
|
|
idx = JOBS.index(job)
|
|
for k, extra in enumerate(sets[1:], 1):
|
|
nj = new_job([s.original for s in extra], job["password"], job["dest"],
|
|
where=job.get("where"), raw=job.get("raw"), fmt=job.get("fmt"),
|
|
comp=job.get("comp"))
|
|
nj["fmt_set"] = job.get("fmt_set", False)
|
|
nj["checks"] = {k: v for k, v in (job.get("checks") or {}).items()
|
|
if k in {x.name.lower() for x in extra}}
|
|
nj["sources"] = describe(extra)
|
|
nj["title"] = E.display_name(extra[0].name)
|
|
JOBS.insert(idx + k, nj)
|
|
job["lines"] = [s.original for s in sets[0]]
|
|
srcs = sets[0]
|
|
setj(job, sources=describe(srcs), title=job["title"] or E.display_name(srcs[0].name))
|
|
save_jobs()
|
|
info = transfer_job(job, srcs, cancel)
|
|
setj(job, info=info, status="en cola para descomprimir",
|
|
phase="Enviado. Esperando turno para descomprimir")
|
|
jlog(job, "Envio completo")
|
|
with WAKE:
|
|
EXTRACT_Q.append(job["id"])
|
|
WAKE.notify_all()
|
|
except NeedsDecision:
|
|
setj(job, status="pausado", phase="Ya está en la consola: elige qué hacer", speed=0.0)
|
|
ask = job.get("ask") or {}
|
|
notify("warn", "Ya está en la PS5: %s" % (job.get("title") or ask.get("tid") or ""),
|
|
"Elige en la cola si lo envías igualmente, lo reemplazas o lo cancelas.",
|
|
{"tab": "Transfers", "job": job["id"]})
|
|
except E.Cancelled:
|
|
stopped(job)
|
|
except Exception as e:
|
|
msg = str(e)
|
|
if "perdida" in msg:
|
|
free = free_space(E.BFpilot(cfg_snapshot()))
|
|
if free is not None and free < margin_bytes():
|
|
msg += " -- La PS5 solo tiene %s libres: seguramente se lleno el disco." % human(free)
|
|
setj(job, status="error", error=msg, phase="Error")
|
|
jlog(job, "ERROR: %s" % msg)
|
|
record_history(job)
|
|
traceback.print_exc()
|
|
save_jobs()
|
|
|
|
|
|
def extract_worker():
|
|
while True:
|
|
with WAKE:
|
|
while not EXTRACT_Q:
|
|
WAKE.wait()
|
|
job = find(EXTRACT_Q.pop(0))
|
|
if job is None or job["status"] != "en cola para descomprimir":
|
|
continue
|
|
cancel = CANCELS.setdefault(job["id"], threading.Event())
|
|
try:
|
|
placed = extract_job(job, job["info"], cancel)
|
|
try:
|
|
check_compat(job, placed)
|
|
except Exception as e:
|
|
jlog(job, "No pude comprobar el firmware: %s" % e)
|
|
is_game = (job.pop("_placed_game", False)
|
|
or any(p.endswith("-app") or p.lower().endswith(E.IMAGE_EXTS) for p in placed)) \
|
|
and (job.get("dest", "").startswith("/data/homebrew") or "/homebrew" in job.get("dest", ""))
|
|
is_pkg = any(p.lower().endswith(".pkg") for p in placed)
|
|
if is_pkg:
|
|
jlog(job, "Es un .fpkg: instálalo desde /data/pkg con el instalador de paquetes "
|
|
"(etaHEN, ItemzFlow o ps5upload)")
|
|
setj(job, status="hecho", result=placed, extract_text="",
|
|
phase=("Listo en /data/pkg: instálalo con el instalador de paquetes" if is_pkg
|
|
else "Listo. ShadowMountPlus lo añadirá al inicio en unos segundos" if is_game
|
|
else "Listo. Copiado en la PS5"))
|
|
jlog(job, "Terminado")
|
|
record_history(job)
|
|
except NeedsDecision:
|
|
setj(job, status="pausado", phase="Ya está en la consola: elige qué hacer", speed=0.0)
|
|
notify("warn", "Ya está en la PS5: %s" % (job.get("title") or ""),
|
|
"Elige en la cola si lo colocas igualmente, reemplazas la que hay o cancelas.",
|
|
{"tab": "Transfers", "job": job["id"]})
|
|
except E.Cancelled:
|
|
stopped(job)
|
|
except Exception as e:
|
|
msg = str(e)
|
|
if "perdida" in msg:
|
|
free = free_space(E.BFpilot(cfg_snapshot()))
|
|
if free is not None and free < margin_bytes():
|
|
msg += " -- La PS5 solo tiene %s libres: seguramente se lleno el disco." % human(free)
|
|
setj(job, status="error", error=msg, phase="Error")
|
|
jlog(job, "ERROR: %s" % msg)
|
|
record_history(job)
|
|
traceback.print_exc()
|
|
save_jobs()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Firmware: avisar de juegos que tu PS5 no podra arrancar
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def check_compat(job, placed):
|
|
if job.get("raw"):
|
|
return
|
|
folders = [p for p in placed or [] if not p.lower().endswith(E.IMAGE_EXTS + (".pkg",))]
|
|
if not folders:
|
|
return
|
|
cfg = cfg_snapshot()
|
|
f = E.Ftp(cfg).connect()
|
|
try:
|
|
for p in folders:
|
|
try:
|
|
facts = F.inspect_remote_game(f, p)
|
|
except ftplib.all_errors:
|
|
continue
|
|
if not facts.get("tid"):
|
|
continue
|
|
remember_title(facts["tid"], facts.get("title"), facts.get("need_fw"), facts.get("fw_param"),
|
|
extra={"backport": facts.get("backport")})
|
|
check_fw_warning(job, facts["tid"], facts.get("title"), facts.get("need_fw"), facts.get("fw_param"),
|
|
facts.get("backport"))
|
|
finally:
|
|
try:
|
|
f.quit()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Biblioteca: los juegos y aplicaciones de la consola, con portada y firmware
|
|
# ---------------------------------------------------------------------------
|
|
|
|
LIB = {"busy": False, "done": 0, "total": 0, "current": "", "items": None, "error": "", "t": 0}
|
|
LIB_CANCEL = threading.Event()
|
|
LZ4_NAME_RE = re.compile(r"(?i)(^|[-_. \[(])lz4([-_. \])]|$)")
|
|
LIB_IMAGE_RE = re.compile(r"\.(ffpkg|exfat|ffpfsc|ffpfs|ufs2?)$", re.I)
|
|
|
|
|
|
GU_TID = "PPSA99440" # PS5 Game Updater (theghostonline): su web va en el puerto 7920
|
|
|
|
|
|
def gu_status():
|
|
"""¿Esta PS5 Game Updater en la consola, bien colocado y en marcha?"""
|
|
cfg = cfg_snapshot()
|
|
out = {"present": False, "running": False, "url": "", "fix_from": "", "problem": ""}
|
|
|
|
def look(f):
|
|
names = {n: v for n, v in E.ftp_listdir(f, "/data/homebrew")}
|
|
if GU_TID in names and names[GU_TID]["type"] == "dir":
|
|
sub = {n for n, _ in E.ftp_listdir(f, "/data/homebrew/" + GU_TID)}
|
|
out["present"] = "sce_sys" in sub
|
|
if not out["present"]:
|
|
out["problem"] = "La carpeta /data/homebrew/%s no tiene sce_sys: está incompleta." % GU_TID
|
|
for n, v in names.items():
|
|
if n == GU_TID or GU_TID not in n.upper() or v["type"] != "dir":
|
|
continue
|
|
p = "/data/homebrew/" + n
|
|
sub = {k: w for k, w in E.ftp_listdir(f, p)}
|
|
if "sce_sys" in sub:
|
|
out["fix_from"] = p
|
|
else:
|
|
inner = [k for k, w in sub.items() if w["type"] == "dir"]
|
|
for k in inner:
|
|
if "sce_sys" in {x for x, _ in E.ftp_listdir(f, p + "/" + k)}:
|
|
out["fix_from"] = p + "/" + k
|
|
break
|
|
if out["fix_from"]:
|
|
out["problem"] = ("Está en %s, pero tiene que estar en /data/homebrew/%s para que funcione."
|
|
% (out["fix_from"], GU_TID))
|
|
break
|
|
port = 7920
|
|
try:
|
|
raw = F.ftp_read(f, "/data/GameUpdater/engine.port", 0, 32).decode("ascii", "ignore").strip()
|
|
if raw.isdigit():
|
|
port = int(raw)
|
|
except Exception:
|
|
pass
|
|
return port
|
|
try:
|
|
port = E.Ftp(cfg).call(look)
|
|
except Exception as e:
|
|
out["problem"] = "No pude mirarlo: %s" % e
|
|
return out
|
|
out["url"] = "http://%s:%d/" % (cfg["ps5_ip"], port)
|
|
try:
|
|
s = socket.create_connection((cfg["ps5_ip"], port), timeout=1.5)
|
|
s.close()
|
|
out["running"] = True
|
|
except OSError:
|
|
pass
|
|
return out
|
|
|
|
|
|
def library_bases(bf, f):
|
|
if bf.alive():
|
|
try:
|
|
return [b for b in game_bases(bf) if b.endswith("/homebrew") or b == "/data/homebrew"]
|
|
except Exception:
|
|
pass
|
|
out = ["/data/homebrew"]
|
|
for b in ["/mnt/usb%d/homebrew" % i for i in range(4)] + ["/mnt/ext%d/homebrew" % i for i in range(2)]:
|
|
try:
|
|
E.ftp_listdir(f, b)
|
|
out.append(b)
|
|
except ftplib.all_errors:
|
|
pass
|
|
return out
|
|
|
|
|
|
def library_scan(refresh=False):
|
|
cfg = cfg_snapshot()
|
|
bf = E.BFpilot(cfg)
|
|
alive = bool(bf.alive())
|
|
cache = lib_load()
|
|
ents = cache["entries"]
|
|
titles = cache["titles"]
|
|
conn = {"f": E.Ftp(cfg).connect()}
|
|
ROOT_NAMES = {"system_data", "system_ex", "dev", "mnt", "preinst", "user"}
|
|
|
|
def listdir(path):
|
|
"""Con BFpilot su listado (fiable); si no, FTP. Mismo formato que E.ftp_listdir."""
|
|
if alive:
|
|
try:
|
|
return [(e["name"], {"type": "dir" if e.get("dir") else "file", "size": e.get("size") or 0,
|
|
"mtime": e.get("mtime"), "mode": e.get("mode")}) for e in bf.listdir(path)]
|
|
except E.PipeError:
|
|
raise ftplib.error_perm("550 no existe")
|
|
return E.ftp_listdir(ftp(), path)
|
|
|
|
def ftp():
|
|
try:
|
|
conn["f"].voidcmd("NOOP")
|
|
except Exception:
|
|
try:
|
|
conn["f"].close()
|
|
except Exception:
|
|
pass
|
|
conn["f"] = E.Ftp(cfg).connect()
|
|
return conn["f"]
|
|
items = []
|
|
try:
|
|
work = []
|
|
for base in library_bases(bf, ftp()):
|
|
try:
|
|
listing = listdir(base)
|
|
except ftplib.all_errors:
|
|
continue
|
|
if len(ROOT_NAMES & {n for n, _ in listing}) >= 3:
|
|
print("Biblioteca: %s devolvio la raiz de la consola, la salto" % base)
|
|
continue # servidor que lista otra carpeta: no es la buena
|
|
for n, x in listing:
|
|
work.append((base, n, x))
|
|
with LOCK:
|
|
LIB.update(total=len(work), done=0)
|
|
# imagenes montadas por ShadowMountPlus: /mnt/shadowmnt/<imagen>_<hash> (y pfsc/...). Dentro estan
|
|
# su param.json y su portada, asi que las imagenes tambien tienen nombre y portada.
|
|
mounts = []
|
|
for mb in ("/mnt/shadowmnt", "/mnt/shadowmnt/pfsc"):
|
|
try:
|
|
ml = listdir(mb)
|
|
except ftplib.all_errors:
|
|
try:
|
|
ml = E.ftp_listdir(ftp(), mb) # BFpilot no siempre lista los puntos de montaje
|
|
except ftplib.all_errors:
|
|
continue
|
|
for n, v in ml:
|
|
if v["type"] != "dir" or n == "pfsc":
|
|
continue
|
|
mp = mb + "/" + n
|
|
c = ents.get("mount:" + mp)
|
|
if c and c.get("mtime") == v.get("mtime") and (c.get("facts") or {}).get("v") == 4:
|
|
facts = c["facts"]
|
|
else:
|
|
try:
|
|
try:
|
|
sub = listdir(mp)
|
|
except ftplib.all_errors:
|
|
sub = E.ftp_listdir(ftp(), mp)
|
|
if not any(k == "sce_sys" and w["type"] == "dir" for k, w in sub):
|
|
continue
|
|
facts = E.Ftp(cfg).call(lambda fx: F.inspect_remote_game(fx, mp, sub))
|
|
if any(k.lower().startswith(("ampr_assets", "ampr_emu")) for k, w in sub):
|
|
facts["lz4"] = True
|
|
facts["v"] = 4 if facts.get("tid") else 0
|
|
except ftplib.all_errors:
|
|
continue
|
|
ents["mount:" + mp] = {"mtime": v.get("mtime"), "facts": facts}
|
|
mounts.append({"path": mp, "key": n.rsplit("_", 1)[0].lower(), "facts": facts})
|
|
|
|
def mount_for(fname, tid):
|
|
low = fname.lower()
|
|
stem = low.rsplit(".", 1)[0]
|
|
for m in mounts:
|
|
if m["key"] in (low, stem):
|
|
return m
|
|
if tid:
|
|
for m in mounts:
|
|
if (m["facts"].get("tid") or "").upper() == tid.upper():
|
|
return m
|
|
return None
|
|
for i, (base, name, x) in enumerate(work):
|
|
if LIB_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
path = base + "/" + name
|
|
with LOCK:
|
|
LIB.update(done=i, current=path)
|
|
drive = "USB" if base.startswith("/mnt/") else "Interno"
|
|
if x["type"] == "dir":
|
|
c = ents.get(path)
|
|
if c and not refresh and c.get("mtime") == x.get("mtime") and (c.get("facts") or {}).get("v") == 4:
|
|
facts = c["facts"]
|
|
else:
|
|
try:
|
|
listing = listdir(path)
|
|
if any(n == "sce_sys" and v["type"] == "dir" for n, v in listing):
|
|
# una conexion por juego (como las portadas): leer el eboot.bin a medias deja
|
|
# algunas conexiones descolocadas y fallaban las lecturas de los siguientes
|
|
facts = E.Ftp(cfg).call(lambda fx: F.inspect_remote_game(fx, path, listing))
|
|
if not facts.get("tid") and facts.get("icon"):
|
|
facts = E.Ftp(cfg).call(lambda fx: F.inspect_remote_game(fx, path, listing))
|
|
# carpeta empaquetada en LZ4 (PS5 Dump Forge): lleva ampr_assets.index
|
|
if any(n.lower().startswith(("ampr_assets", "ampr_emu")) for n, v in listing):
|
|
facts["lz4"] = True
|
|
else:
|
|
facts = {"incomplete": True}
|
|
facts["v"] = 4 if (facts.get("tid") or facts.get("incomplete") or not facts.get("icon")) else 0
|
|
except ftplib.all_errors as e:
|
|
facts = {"error": str(e)}
|
|
c = {"mtime": x.get("mtime"), "facts": facts}
|
|
ents[path] = c
|
|
it = dict(facts)
|
|
it.update(path=path, name=name, kind="folder", drive=drive, size=c.get("size"),
|
|
cover=bool(facts.get("icon")))
|
|
if not it.get("incomplete") and LZ4_NAME_RE.search(name):
|
|
it["lz4"] = True
|
|
if not it.get("tid") and not it.get("incomplete"):
|
|
# sin param.json legible: el Title ID del nombre y el titulo si ya lo conociamos
|
|
tn = E.title_id(name)
|
|
if tn:
|
|
it["tid"] = tn
|
|
known = titles.get(tn.upper()) or {}
|
|
it["title"] = it.get("title") or known.get("title")
|
|
it["need_fw"] = it.get("need_fw") or known.get("need_fw")
|
|
if it.get("tid"):
|
|
t = titles.setdefault(it["tid"].upper(), {})
|
|
if it.get("title"):
|
|
t["title"] = it["title"]
|
|
if it.get("need_fw"):
|
|
t["need_fw"] = it["need_fw"]
|
|
items.append(it)
|
|
elif LIB_IMAGE_RE.search(name):
|
|
tid = E.title_id(name)
|
|
m = mount_for(name, tid)
|
|
if m and not tid:
|
|
tid = m["facts"].get("tid")
|
|
t = titles.get((tid or "").upper(), {})
|
|
mf = m["facts"] if m else {}
|
|
it = {"path": path, "name": name, "kind": "image", "drive": drive,
|
|
"lz4": bool(LZ4_NAME_RE.search(name)) or bool(mf.get("lz4")),
|
|
"ext": LIB_IMAGE_RE.search(name).group(1).lower(), "size": x.get("size"),
|
|
"tid": tid, "title": mf.get("title") or t.get("title"),
|
|
"version": mf.get("version"), "need_fw": mf.get("need_fw") or t.get("need_fw"),
|
|
"backport": mf.get("backport") or t.get("backport"),
|
|
"cover": bool(mf.get("icon") or t.get("cover"))}
|
|
if m and mf.get("icon"):
|
|
it["cover_path"] = m["path"]
|
|
if m:
|
|
it["mounted"] = m["path"]
|
|
if tid and it["title"]:
|
|
tt = titles.setdefault(tid.upper(), {})
|
|
tt["title"] = it["title"]
|
|
if it.get("need_fw"):
|
|
tt["need_fw"] = it["need_fw"]
|
|
items.append(it)
|
|
# portadas y nombres que faltan: la PS5 guarda los de cada aplicacion registrada en su menu en
|
|
# /user/appmeta/<Title ID>/ (icon0.png y param.json). Sirve para imagenes y carpetas sin param.json.
|
|
try:
|
|
meta_list = E.Ftp(cfg).call(lambda fx: E.ftp_listdir(fx, "/user/appmeta"))
|
|
except ftplib.all_errors:
|
|
meta_list = []
|
|
meta_ids = {n.upper() for n, v in meta_list if v["type"] == "dir"}
|
|
# aplicaciones instaladas en la consola (PS5 y PS4) que no son copias de /data/homebrew
|
|
have = {(it.get("tid") or "").upper() for it in items}
|
|
try:
|
|
user_app = {n.upper() for n, v in listdir("/user/app")}
|
|
except ftplib.all_errors:
|
|
user_app = set()
|
|
for n, v in sorted(meta_list):
|
|
tidu = n.upper()
|
|
if v["type"] != "dir" or not re.match(r"^(PPSA|CUSA)\d{5}$", tidu) or tidu in have:
|
|
continue
|
|
mp = "/user/appmeta/" + n
|
|
c = ents.get("installed:" + tidu)
|
|
if not (c and not refresh and c.get("mtime") == v.get("mtime") and (c.get("facts") or {}).get("v") == 4):
|
|
try:
|
|
def look(fx, mp=mp, tidu=tidu):
|
|
names = {k for k, _ in E.ftp_listdir(fx, mp)}
|
|
out = {"icon": "icon0.png" in names, "v": 4}
|
|
if "param.json" in names:
|
|
raw = F.ftp_read(fx, mp + "/param.json", 0, 512 * 1024)
|
|
out.update(F.param_facts(raw.decode("utf-8-sig", "replace")))
|
|
out["need_fw"] = out.get("fw_param")
|
|
elif "param.sfo" in names:
|
|
out.update(F.sfo_facts(F.ftp_read(fx, mp + "/param.sfo", 0, 256 * 1024)))
|
|
return out
|
|
facts = E.Ftp(cfg).call(look)
|
|
except ftplib.all_errors:
|
|
continue
|
|
c = ents["installed:" + tidu] = {"mtime": v.get("mtime"), "facts": facts}
|
|
mf = c["facts"]
|
|
if mf.get("extra"):
|
|
continue
|
|
if mf.get("title"):
|
|
titles.setdefault(tidu, {})["title"] = mf["title"]
|
|
ps4 = tidu.startswith("CUSA")
|
|
items.append({"path": "/user/app/" + n if tidu in user_app else mp, "name": n, "kind": "installed",
|
|
"platform": "PS4" if ps4 else "PS5", "drive": "Interno", "tid": tidu,
|
|
"title": mf.get("title"), "version": mf.get("version"), "need_fw": mf.get("need_fw"),
|
|
"cover": bool(mf.get("icon")), "cover_path": mp if mf.get("icon") else None,
|
|
"size": (ents.get("/user/app/" + n) or {}).get("size")})
|
|
need = [it for it in items if it.get("tid") and not it.get("incomplete") and it["kind"] != "installed"
|
|
and (not it.get("cover") or not it.get("title"))]
|
|
if need:
|
|
for it in need:
|
|
tidu = it["tid"].upper()
|
|
if tidu not in meta_ids:
|
|
continue
|
|
mp = "/user/appmeta/" + tidu
|
|
c = ents.get("appmeta:" + tidu)
|
|
if not (c and (c.get("facts") or {}).get("v") == 4 and not refresh):
|
|
try:
|
|
def look(fx, mp=mp):
|
|
names = {n for n, _ in E.ftp_listdir(fx, mp)}
|
|
out = {"icon": "icon0.png" in names, "v": 4}
|
|
if "param.json" in names:
|
|
raw = F.ftp_read(fx, mp + "/param.json", 0, 512 * 1024)
|
|
out.update(F.param_facts(raw.decode("utf-8-sig", "replace")))
|
|
return out
|
|
facts = E.Ftp(cfg).call(look)
|
|
except ftplib.all_errors:
|
|
continue
|
|
c = ents["appmeta:" + tidu] = {"facts": facts}
|
|
mf = c["facts"]
|
|
if mf.get("icon") and not it.get("cover"):
|
|
it["cover"] = True
|
|
it["cover_path"] = mp
|
|
if mf.get("title") and not it.get("title"):
|
|
it["title"] = mf["title"]
|
|
titles.setdefault(tidu, {})["title"] = mf["title"]
|
|
if mf.get("version") and not it.get("version"):
|
|
it["version"] = mf["version"]
|
|
# el firmware que pide su param.json (dentro de una imagen no se puede mirar el eboot.bin)
|
|
fwp = mf.get("need_fw") or mf.get("fw_param")
|
|
if fwp and not it.get("need_fw"):
|
|
it["need_fw"] = fwp
|
|
it["fw_from_param"] = True
|
|
# tamano de las carpetas (rapido con BFpilot; por FTP seria muy lento)
|
|
if alive:
|
|
todo = [it for it in items if (it["kind"] == "folder" or (it["kind"] == "installed" and it["path"].startswith("/user/app/")))
|
|
and it.get("size") is None]
|
|
for k, it in enumerate(todo):
|
|
if LIB_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
with LOCK:
|
|
LIB.update(current="Calculando tamaños %d de %d" % (k + 1, len(todo)))
|
|
sz = bf.du(it["path"], timeout=120)
|
|
if sz is not None:
|
|
it["size"] = sz
|
|
ents.setdefault(it["path"], {})["size"] = sz
|
|
# quitar de la cache lo que ya no esta
|
|
seen = {it["path"] for it in items} | {"mount:" + m["path"] for m in mounts} | \
|
|
{"appmeta:" + it["tid"].upper() for it in items if it.get("tid")} | \
|
|
{"installed:" + it["tid"].upper() for it in items if it.get("tid")}
|
|
for p in list(ents):
|
|
if p not in seen:
|
|
ents.pop(p, None)
|
|
lib_save(cache)
|
|
finally:
|
|
try:
|
|
conn["f"].quit()
|
|
except Exception:
|
|
pass
|
|
# repetidos: mismo Title ID en dos sitios
|
|
by = {}
|
|
for it in items:
|
|
if it.get("tid") and not it.get("extra"):
|
|
by.setdefault(it["tid"].upper(), []).append(it)
|
|
for lst in by.values():
|
|
if len(lst) > 1:
|
|
for it in lst:
|
|
it["dup"] = [o["path"] for o in lst if o is not it]
|
|
items.sort(key=lambda it: ((it.get("title") or it["name"]).lower(), it["path"]))
|
|
return {"items": items, "bfpilot": alive, "t": time.time(), "mounts": len(mounts)}
|
|
|
|
|
|
def library_start(refresh=False):
|
|
with LOCK:
|
|
if LIB["busy"]:
|
|
return
|
|
LIB.update(busy=True, done=0, total=0, current="", error="")
|
|
LIB_CANCEL.clear()
|
|
|
|
def run():
|
|
try:
|
|
res = library_scan(refresh)
|
|
with LOCK:
|
|
LIB["items"] = res
|
|
LIB["t"] = res["t"]
|
|
except E.Cancelled:
|
|
with LOCK:
|
|
LIB["error"] = "Cancelado"
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
with LOCK:
|
|
LIB["error"] = str(e)
|
|
finally:
|
|
with LOCK:
|
|
LIB["busy"] = False
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
|
|
def cover_png(path=None, tid=None):
|
|
"""Bytes de la portada (icon0.png) de una aplicacion de la consola, guardada en cache."""
|
|
import hashlib
|
|
if tid:
|
|
t = lib_load()["titles"].get(tid.upper()) or {}
|
|
fn = t.get("cover")
|
|
if fn:
|
|
fp = os.path.join(COVER_DIR, os.path.basename(fn))
|
|
if os.path.isfile(fp):
|
|
with open(fp, "rb") as fh:
|
|
return fh.read()
|
|
return None
|
|
path = fm_clean(path)
|
|
if not (path.startswith("/data/") or path.startswith("/mnt/") or path.startswith("/user/appmeta/")):
|
|
return None
|
|
c = lib_load()["entries"].get(path) or {}
|
|
key = hashlib.sha1(("%s|%s" % (path, c.get("mtime"))).encode("utf-8")).hexdigest()[:20]
|
|
fp = os.path.join(COVER_DIR, key + ".png")
|
|
if os.path.isfile(fp):
|
|
with open(fp, "rb") as fh:
|
|
return fh.read()
|
|
icon = path + ("/icon0.png" if path.startswith("/user/appmeta/") else "/sce_sys/icon0.png")
|
|
data = E.Ftp(cfg_snapshot()).call(lambda f: F.ftp_read(f, icon, 0, 8 * 1024 * 1024))
|
|
if not data.startswith(b"\x89PNG"):
|
|
return None
|
|
os.makedirs(COVER_DIR, exist_ok=True)
|
|
with open(fp + ".tmp", "wb") as fo:
|
|
fo.write(data)
|
|
os.replace(fp + ".tmp", fp)
|
|
return data
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Programar la cola, no dormir el PC y apagar/suspender al terminar
|
|
# ---------------------------------------------------------------------------
|
|
|
|
SCHED = {"start": 0, "after": "none", "seen_busy": False, "countdown": 0}
|
|
|
|
|
|
def sched_state():
|
|
with LOCK:
|
|
return {"start": SCHED["start"], "after": SCHED["after"], "countdown": SCHED["countdown"]}
|
|
|
|
|
|
def sched_save():
|
|
with LOCK:
|
|
SETTINGS["sched"] = {"start": SCHED["start"], "after": SCHED["after"]}
|
|
save_settings()
|
|
|
|
|
|
def sched_set(b):
|
|
with WAKE:
|
|
if "start" in b:
|
|
v = str(b.get("start") or "").strip()
|
|
if not v:
|
|
SCHED["start"] = 0
|
|
else:
|
|
m = re.match(r"^(\d{1,2}):(\d{2})$", v)
|
|
if not m or int(m.group(1)) > 23 or int(m.group(2)) > 59:
|
|
raise E.PipeError("Hora no valida (usa HH:MM)")
|
|
lt = time.localtime()
|
|
t = time.mktime((lt.tm_year, lt.tm_mon, lt.tm_mday, int(m.group(1)), int(m.group(2)), 0, 0, 0, -1))
|
|
if t <= time.time():
|
|
t += 86400
|
|
SCHED["start"] = t
|
|
if "after" in b:
|
|
a = b.get("after")
|
|
SCHED["after"] = a if a in ("sleep", "shutdown") else "none"
|
|
SCHED["countdown"] = 0
|
|
SCHED["seen_busy"] = False
|
|
if b.get("cancel_countdown"):
|
|
SCHED.update(after="none", countdown=0, seen_busy=False)
|
|
if b.get("now"):
|
|
SCHED["start"] = 0
|
|
WAKE.notify_all()
|
|
sched_save()
|
|
return sched_state()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Copia de seguridad de la consola en el PC (partidas, configuracion y base de datos de aplicaciones)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
BK = {"busy": False, "what": "", "done": 0, "total": 0, "files": 0, "current": "", "error": "", "last": "", "t": 0}
|
|
BK_CANCEL = threading.Event()
|
|
BK_CONFIG_DIRS = ["/data/shadowmount", "/data/shadowmountplus", "/data/pldmgr", "/data/etaHEN", "/data/GameUpdater",
|
|
"/data/ps5_autoloader", "/data/kstuff"]
|
|
BK_APPDB = ["/system_data/priv/mms/app.db", "/system_data/priv/mms/appinfo.db", "/system_data/priv/mms/addcont.db"]
|
|
BK_SAVE_DIRS = ("savedata_prospero", "savedata")
|
|
BK_MAX_FILE = 200 * 1024 * 1024 # en la configuracion no se copian archivos enormes
|
|
|
|
|
|
def backup_dir(cfg=None):
|
|
d = ((cfg or cfg_snapshot()).get("backup_dir") or "").strip().strip('"')
|
|
return d or os.path.join(os.path.expanduser("~"), "Documents", "PS5 Directo", "Copias")
|
|
|
|
|
|
def _ftp_walk_sizes(f, root, out, cancel, limit=None):
|
|
"""[(ruta, tamano)] de todos los archivos bajo root (vacio si no existe)."""
|
|
try:
|
|
listing = E.ftp_listdir(f, root)
|
|
except ftplib.all_errors:
|
|
return out
|
|
for n, v in listing:
|
|
if cancel.is_set():
|
|
raise E.Cancelled()
|
|
p = root.rstrip("/") + "/" + n
|
|
if v["type"] == "dir":
|
|
_ftp_walk_sizes(f, p, out, cancel, limit)
|
|
elif v["type"] == "file" and (limit is None or (v.get("size") or 0) <= limit):
|
|
out.append((p, v.get("size") or 0))
|
|
return out
|
|
|
|
|
|
def _save_roots(f):
|
|
"""Carpetas de partidas de cada usuario de la consola."""
|
|
roots = []
|
|
try:
|
|
users = [n for n, v in E.ftp_listdir(f, "/user/home") if v["type"] == "dir"]
|
|
except ftplib.all_errors:
|
|
return roots
|
|
for u in users:
|
|
try:
|
|
sub = {n for n, v in E.ftp_listdir(f, "/user/home/" + u) if v["type"] == "dir"}
|
|
except ftplib.all_errors:
|
|
continue
|
|
for d in BK_SAVE_DIRS:
|
|
if d in sub:
|
|
roots.append("/user/home/%s/%s" % (u, d))
|
|
return roots
|
|
|
|
|
|
def backup_run(sections=None, label="copia"):
|
|
"""Hace la copia en un .zip con fecha. sections: saves, config, appdb, list."""
|
|
import zipfile
|
|
cfg = cfg_snapshot()
|
|
if sections is None:
|
|
sections = [k for k in ("saves", "config", "appdb") if cfg.get("backup_" + k, True)] + ["list"]
|
|
BK_CANCEL.clear()
|
|
with LOCK:
|
|
BK.update(busy=True, what="backup", done=0, total=0, files=0, current="Buscando qué copiar…", error="")
|
|
out_dir = backup_dir(cfg)
|
|
os.makedirs(out_dir, exist_ok=True)
|
|
name = "PS5-%s-%s.zip" % (label, time.strftime("%Y-%m-%d_%H%M"))
|
|
final = os.path.join(out_dir, name)
|
|
tmp = final + ".part"
|
|
try:
|
|
f = E.Ftp(cfg).connect()
|
|
try:
|
|
todo = [] # (seccion, ruta, tamano)
|
|
if "saves" in sections:
|
|
for r in _save_roots(f):
|
|
todo += [("saves", p, s) for p, s in _ftp_walk_sizes(f, r, [], BK_CANCEL)]
|
|
if "config" in sections:
|
|
for r in BK_CONFIG_DIRS:
|
|
todo += [("config", p, s) for p, s in _ftp_walk_sizes(f, r, [], BK_CANCEL, BK_MAX_FILE)]
|
|
if "appdb" in sections:
|
|
for p in BK_APPDB:
|
|
try:
|
|
sz = f.size(p)
|
|
todo.append(("appdb", p, sz or 0))
|
|
except ftplib.all_errors:
|
|
pass
|
|
with LOCK:
|
|
BK.update(total=sum(x[2] for x in todo), files=len(todo))
|
|
manifest = {"app": "PS5 Directo", "version": VERSION, "date": time.strftime("%Y-%m-%d %H:%M:%S"),
|
|
"ps5_ip": cfg.get("ps5_ip"), "console_fw": cfg.get("console_fw"), "sections": sections,
|
|
"files": []}
|
|
done = 0
|
|
with zipfile.ZipFile(tmp, "w", zipfile.ZIP_DEFLATED, allowZip64=True) as z:
|
|
for sec, p, sz in todo:
|
|
if BK_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
with LOCK:
|
|
BK["current"] = p
|
|
arc = "consola" + p
|
|
try:
|
|
with z.open(zipfile.ZipInfo(arc, time.localtime()[:6]), "w", force_zip64=True) as dst:
|
|
f.retrbinary("RETR " + p, dst.write, 1024 * 1024)
|
|
manifest["files"].append({"section": sec, "path": p, "size": sz})
|
|
except ftplib.all_errors as e:
|
|
manifest.setdefault("skipped", []).append({"path": p, "error": str(e)[:200]})
|
|
try:
|
|
f.close()
|
|
except Exception:
|
|
pass
|
|
f = E.Ftp(cfg).connect()
|
|
done += sz
|
|
with LOCK:
|
|
BK["done"] = done
|
|
if "list" in sections:
|
|
items = (lib_load().get("entries") or {})
|
|
titles = lib_load().get("titles") or {}
|
|
z.writestr("lista_de_la_consola.json", json.dumps(
|
|
{"titles": titles, "paths": sorted(k for k in items if not k.startswith(("mount:", "appmeta:")))},
|
|
ensure_ascii=False, indent=1))
|
|
z.writestr("manifest.json", json.dumps(manifest, ensure_ascii=False, indent=1))
|
|
finally:
|
|
try:
|
|
f.quit()
|
|
except Exception:
|
|
pass
|
|
os.replace(tmp, final)
|
|
keep = int(cfg.get("backup_keep") or 10)
|
|
pre = sorted(x for x in os.listdir(out_dir) if x.startswith("PS5-antes-de-restaurar-") and x.endswith(".zip"))
|
|
olds = sorted(x for x in os.listdir(out_dir) if x.startswith("PS5-copia-") and x.endswith(".zip"))
|
|
for x in (olds[:-keep] if keep > 0 else []) + pre[:-5]:
|
|
try:
|
|
os.remove(os.path.join(out_dir, x))
|
|
except OSError:
|
|
pass
|
|
with LOCK:
|
|
SETTINGS["backup_last"] = time.time()
|
|
BK.update(last=final)
|
|
save_settings()
|
|
nf = len(manifest["files"])
|
|
notify("ok", "Copia de seguridad hecha", "%d archivos (%s) en %s" % (nf, human(done), final), {"tab": "Backup"})
|
|
return final
|
|
except E.Cancelled:
|
|
with LOCK:
|
|
BK["error"] = "Cancelada"
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
with LOCK:
|
|
BK["error"] = str(e)
|
|
notify("err", "No se pudo hacer la copia de seguridad", str(e))
|
|
finally:
|
|
try:
|
|
if os.path.exists(tmp):
|
|
os.remove(tmp)
|
|
except OSError:
|
|
pass
|
|
with LOCK:
|
|
BK.update(busy=False, current="", t=time.time())
|
|
return None
|
|
|
|
|
|
def backup_list():
|
|
d = backup_dir()
|
|
out = []
|
|
if os.path.isdir(d):
|
|
import zipfile
|
|
for x in sorted(os.listdir(d), key=lambda n: os.path.getmtime(os.path.join(d, n)), reverse=True):
|
|
if not x.endswith(".zip") or not x.startswith("PS5-"):
|
|
continue
|
|
fp = os.path.join(d, x)
|
|
info = {"name": x, "path": fp, "size": os.path.getsize(fp), "t": os.path.getmtime(fp), "saves": [],
|
|
"names": {}}
|
|
try:
|
|
with zipfile.ZipFile(fp) as z:
|
|
m = json.loads(z.read("manifest.json"))
|
|
info["sections"] = m.get("sections")
|
|
ids = set()
|
|
for it in m.get("files") or []:
|
|
if it.get("section") == "saves":
|
|
parts = it["path"].split("/")
|
|
if len(parts) > 5:
|
|
ids.add(parts[5])
|
|
info["saves"] = sorted(ids)
|
|
titles = lib_load().get("titles") or {}
|
|
info["names"] = {i: (titles.get(i.upper()) or {}).get("title") for i in ids}
|
|
info["files"] = len(m.get("files") or [])
|
|
except Exception as e:
|
|
info["error"] = str(e)
|
|
out.append(info)
|
|
return out
|
|
|
|
|
|
def backup_restore(path, ids):
|
|
"""Vuelve a poner en la consola las partidas elegidas de una copia (antes guarda las de ahora)."""
|
|
import zipfile
|
|
cfg = cfg_snapshot()
|
|
path = os.path.abspath(path)
|
|
if not path.startswith(os.path.abspath(backup_dir(cfg))) or not os.path.isfile(path):
|
|
raise E.PipeError("Esa copia no está en la carpeta de copias")
|
|
ids = set(ids or [])
|
|
with LOCK:
|
|
BK.update(busy=True, what="restore", done=0, total=0, files=0, current="Guardando antes las partidas de ahora…",
|
|
error="")
|
|
BK_CANCEL.clear()
|
|
try:
|
|
backup_run(["saves"], "antes-de-restaurar")
|
|
with LOCK:
|
|
BK.update(busy=True, what="restore", current="Restaurando…", error="")
|
|
with zipfile.ZipFile(path) as z:
|
|
m = json.loads(z.read("manifest.json"))
|
|
files = [it for it in m.get("files") or [] if it.get("section") == "saves"
|
|
and (not ids or (len(it["path"].split("/")) > 5 and it["path"].split("/")[5] in ids))]
|
|
with LOCK:
|
|
BK.update(total=sum(it.get("size") or 0 for it in files), files=len(files))
|
|
f = E.Ftp(cfg).connect()
|
|
done = 0
|
|
try:
|
|
for it in files:
|
|
if BK_CANCEL.is_set():
|
|
raise E.Cancelled()
|
|
p = it["path"]
|
|
user_dir = "/".join(p.split("/")[:4])
|
|
try:
|
|
E.ftp_listdir(f, user_dir)
|
|
except ftplib.all_errors:
|
|
raise E.PipeError("En la consola no existe %s: esta copia es de otro usuario o de otra "
|
|
"consola" % user_dir)
|
|
with LOCK:
|
|
BK["current"] = p
|
|
E.Ftp.mkdirs(f, posixpath.dirname(p))
|
|
with z.open("consola" + p) as src:
|
|
f.storbinary("STOR " + p, src, 1024 * 1024)
|
|
done += it.get("size") or 0
|
|
with LOCK:
|
|
BK["done"] = done
|
|
finally:
|
|
try:
|
|
f.quit()
|
|
except Exception:
|
|
pass
|
|
notify("ok", "Partidas restauradas", "%d archivos desde %s" % (len(files), os.path.basename(path)),
|
|
{"tab": "Backup"})
|
|
except E.Cancelled:
|
|
with LOCK:
|
|
BK["error"] = "Cancelado"
|
|
except Exception as e:
|
|
with LOCK:
|
|
BK["error"] = str(e)
|
|
notify("err", "No se pudieron restaurar las partidas", str(e))
|
|
finally:
|
|
with LOCK:
|
|
BK.update(busy=False, current="", t=time.time())
|
|
|
|
|
|
def monitor():
|
|
"""Cada pocos segundos: que el PC no se duerma con trabajo y la accion al acabar la cola."""
|
|
awake = None
|
|
last_auto = 0.0
|
|
while True:
|
|
time.sleep(5)
|
|
try:
|
|
# copia de seguridad diaria (si esta activada y la consola responde)
|
|
if (SETTINGS.get("backup_auto") and not BK["busy"] and not busy()
|
|
and time.time() - float(SETTINGS.get("backup_last") or 0) > 24 * 3600
|
|
and time.time() - last_auto > 1800):
|
|
last_auto = time.time()
|
|
try:
|
|
E.Ftp(cfg_snapshot()).call(lambda f: f.voidcmd("NOOP"))
|
|
threading.Thread(target=backup_run, daemon=True).start()
|
|
except Exception:
|
|
pass # consola apagada: se intentara mas tarde
|
|
except Exception:
|
|
traceback.print_exc()
|
|
try:
|
|
b = busy()
|
|
with LOCK:
|
|
want = bool(b and SETTINGS.get("keep_awake", True))
|
|
if want != awake:
|
|
F.keep_awake(want)
|
|
awake = want
|
|
with LOCK:
|
|
after, cd = SCHED["after"], SCHED["countdown"]
|
|
if after not in ("sleep", "shutdown"):
|
|
continue
|
|
if b or SCHED["start"]:
|
|
with LOCK:
|
|
SCHED["seen_busy"] = True
|
|
SCHED["countdown"] = 0
|
|
continue
|
|
if not SCHED["seen_busy"]:
|
|
continue
|
|
if not cd:
|
|
with LOCK:
|
|
SCHED["countdown"] = time.time() + 60
|
|
notify("warn", "Cola terminada: el PC se %s en 1 minuto" %
|
|
("apagará" if after == "shutdown" else "suspenderá"),
|
|
"Pulsa Cancelar en la cola si no quieres.", {"tab": "Transfers"})
|
|
elif time.time() >= cd:
|
|
with LOCK:
|
|
SCHED.update(after="none", countdown=0, seen_busy=False)
|
|
sched_save()
|
|
F.keep_awake(False)
|
|
awake = False
|
|
print(F.power_action(after))
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Payloads (ftpsrv, BFpilot) y PS5 Dump Forge
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def payload_list():
|
|
folder = os.path.join(DATA_DIR, "payloads")
|
|
out = []
|
|
for p in F.PAYLOADS:
|
|
cached = []
|
|
try:
|
|
cached = sorted(n[len(p["id"]) + 1:-4] for n in os.listdir(folder)
|
|
if n.startswith(p["id"] + "-") and n.endswith(".elf"))
|
|
except OSError:
|
|
pass
|
|
out.append({"id": p["id"], "name": p["name"], "what": p["what"], "repo": p["repo"],
|
|
"cached": cached[-1] if cached else None})
|
|
return out
|
|
|
|
|
|
def wait_service(pid, cfg, secs=20):
|
|
t0 = time.time()
|
|
while time.time() - t0 < secs:
|
|
if pid == "ftpsrv":
|
|
try:
|
|
E.Ftp(cfg).connect().quit()
|
|
return True
|
|
except Exception:
|
|
pass
|
|
elif pid == "bfpilot":
|
|
if E.BFpilot(cfg).alive():
|
|
return True
|
|
else:
|
|
return None
|
|
time.sleep(1.5)
|
|
return False
|
|
|
|
|
|
def payload_send(pid=None, path=None):
|
|
cfg = cfg_snapshot()
|
|
if pid:
|
|
path, tag = F.fetch_payload(pid, DATA_DIR, log=print)
|
|
name = next(p["name"] for p in F.PAYLOADS if p["id"] == pid)
|
|
else:
|
|
if not path or not os.path.isfile(path):
|
|
raise E.PipeError("No existe ese archivo")
|
|
name, tag = os.path.basename(path), ""
|
|
with open(path, "rb") as fh:
|
|
data = fh.read(64 * 1024 * 1024)
|
|
F.send_elf(cfg["ps5_ip"], int(cfg.get("elf_port") or 9021), data)
|
|
up = wait_service(pid, cfg) if pid else None
|
|
try:
|
|
test_connection(cfg)
|
|
except Exception:
|
|
pass
|
|
return {"name": name, "tag": tag, "up": up}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Abrir PS5 Directo desde el movil (misma red)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
LAN = {"srv": None, "port": None, "error": ""}
|
|
LAN_HITS = [] # lo ultimo que ha pedido el movil: para saber si llega y si se corta
|
|
LAN_DENY = {"/api/bk/restore", "/api/bk/open", "/api/report/open", "/api/col/set", "/api/lan/firewall", "/api/lan/hits", "/api/update/zip", "/api/update/github", "/api/quit", "/api/pick", "/api/open_ext_folder",
|
|
"/api/fm/open_local", "/api/lan", "/api/forge/download", "/api/payload/file", "/api/fixperms"}
|
|
LAN_LOCKED = {"sevenzip_path", "forge_path", "pc_temp_dir", "update_repo", "lan_access", "lan_port", "lan_token"}
|
|
|
|
|
|
def token_ok(tok):
|
|
if not tok:
|
|
return False
|
|
if secrets.compare_digest(str(tok), TOKEN):
|
|
return True
|
|
with LOCK:
|
|
lt, on = SETTINGS.get("lan_token") or "", SETTINGS.get("lan_access")
|
|
return bool(on and lt and secrets.compare_digest(str(tok), lt))
|
|
|
|
|
|
def lan_start():
|
|
with LOCK:
|
|
port = int(SETTINGS.get("lan_port") or 8780)
|
|
if not SETTINGS.get("lan_token"):
|
|
SETTINGS["lan_token"] = secrets.token_urlsafe(16)
|
|
save_settings()
|
|
if LAN["srv"]:
|
|
return
|
|
try:
|
|
srv = Server(("0.0.0.0", port), LanHandler)
|
|
except OSError as e:
|
|
LAN["error"] = "No pude abrir el puerto %d (%s). Cambia el puerto o cierra lo que lo use." % (port, e)
|
|
raise E.PipeError(LAN["error"])
|
|
threading.Thread(target=srv.serve_forever, daemon=True).start()
|
|
LAN.update(srv=srv, port=port, error="")
|
|
print("Acceso desde el movil: puerto %d" % port)
|
|
|
|
|
|
def lan_stop():
|
|
srv = LAN.get("srv")
|
|
LAN["srv"] = None
|
|
if srv:
|
|
try:
|
|
srv.shutdown()
|
|
srv.server_close()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def lan_info():
|
|
with LOCK:
|
|
tok = SETTINGS.get("lan_token") or ""
|
|
ip_ps5 = SETTINGS.get("ps5_ip") or ""
|
|
out = {"enabled": bool(LAN["srv"]), "url": "", "svg": "", "error": LAN.get("error") or ""}
|
|
if LAN["srv"]:
|
|
ip = F.lan_ip(E.clean_host(ip_ps5)[0] or None)
|
|
if ip:
|
|
out["url"] = "http://%s:%d/#t=%s" % (ip, LAN["port"], tok)
|
|
out["svg"] = F.qr_svg(out["url"])
|
|
out["test_url"] = "http://%s:%d/prueba" % (ip, LAN["port"])
|
|
out["test_svg"] = F.qr_svg(out["test_url"], scale=3)
|
|
else:
|
|
out["error"] = "No sé la IP de este PC en la red local"
|
|
return out
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Servidor web local
|
|
# ---------------------------------------------------------------------------
|
|
|
|
TOKEN = secrets.token_urlsafe(18)
|
|
|
|
|
|
CONN_STATE = {"ftp": None, "bf": None}
|
|
|
|
|
|
def _conn_change(kind, ok, detail):
|
|
"""Avisa solo cuando algo que funcionaba deja de funcionar (y cuando vuelve)."""
|
|
name = "el FTP" if kind == "ftp" else "BFpilot"
|
|
prev = CONN_STATE[kind]
|
|
CONN_STATE[kind] = ok
|
|
if prev is True and not ok:
|
|
notify("warn", "Se perdió la conexión con %s de la PS5" % name, detail)
|
|
elif prev is False and ok:
|
|
notify("info", "Otra vez conectado con %s de la PS5" % name)
|
|
|
|
|
|
def test_connection(cfg):
|
|
out = _test_connection(cfg)
|
|
_conn_change("ftp", out["ftp"] == "ok", out["ftp"])
|
|
_conn_change("bf", str(out["bf"]).startswith("ok"), out["bf"])
|
|
return out
|
|
|
|
|
|
def _test_connection(cfg):
|
|
out = {"ftp": None, "bf": None, "free": None}
|
|
try:
|
|
f = E.Ftp(cfg).connect()
|
|
f.quit()
|
|
out["ftp"] = "ok"
|
|
except Exception as e:
|
|
out["ftp"] = "error: %s" % e
|
|
bf = E.BFpilot(cfg)
|
|
v = bf.alive()
|
|
out["bf"] = ("ok (%s)" % v) if v else "no responde (cargalo desde Payload Manager)"
|
|
if v:
|
|
try:
|
|
st = bf._req("GET", "/api/fs/stat", {"path": "/data"})
|
|
out["free"] = human(int(st.get("availableBytes") or 0))
|
|
except Exception:
|
|
pass
|
|
return out
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Limpieza de restos en /data/ps5directo
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _job_dirs():
|
|
"""Carpetas de trabajo que todavia usa algun trabajo de la cola -> titulo."""
|
|
used = {}
|
|
with LOCK:
|
|
jobs = [dict(j) for j in JOBS if j["status"] != "hecho"]
|
|
for j in jobs:
|
|
title = j.get("title") or "trabajo"
|
|
srcs = j.get("sources") or []
|
|
if srcs:
|
|
used["%s/incoming/%s" % (WORK_ROOT, E.safe_name(E.set_key(srcs[0]["name"])))] = title
|
|
used["%s/incoming/%s" % (WORK_ROOT, j["id"])] = title
|
|
used["%s/extract/%s" % (WORK_ROOT, j["id"])] = title
|
|
return used
|
|
|
|
|
|
def cleanup_scan():
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
if not bf.alive():
|
|
raise E.PipeError("BFpilot no responde: cargalo para poder buscar restos")
|
|
used = _job_dirs()
|
|
items = []
|
|
|
|
def add(path, label):
|
|
size = bf.du(path)
|
|
owner = None
|
|
for u, title in used.items():
|
|
if path == u or path.startswith(u + ".") or path.startswith(u + "/"):
|
|
owner = title
|
|
items.append({"path": path, "label": label, "size": size or 0, "in_use": owner})
|
|
|
|
try:
|
|
top = bf.listdir(WORK_ROOT)
|
|
except Exception:
|
|
top = []
|
|
for e in top:
|
|
n = e["name"]
|
|
if n in ("incoming", "extract") and e.get("dir"):
|
|
try:
|
|
sub = bf.listdir("%s/%s" % (WORK_ROOT, n))
|
|
except Exception:
|
|
sub = []
|
|
for x in sub:
|
|
add("%s/%s/%s" % (WORK_ROOT, n, x["name"]),
|
|
("Partes enviadas: " if n == "incoming" else "Descompresion a medias: ") + x["name"])
|
|
else:
|
|
add("%s/%s" % (WORK_ROOT, n), "Otro: " + n)
|
|
items.sort(key=lambda x: -x["size"])
|
|
return items
|
|
|
|
|
|
def cleanup_delete(paths):
|
|
with LOCK:
|
|
if any(j["status"] in ("extrayendo", "colocando") for j in JOBS):
|
|
raise E.PipeError("Espera a que termine la descompresion: BFpilot esta ocupado")
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
done = []
|
|
for p in paths:
|
|
p = posixpath.normpath(str(p))
|
|
if not p.startswith(WORK_ROOT + "/") or ".." in p:
|
|
continue # solo dentro de la carpeta de trabajo
|
|
bf.delete(p)
|
|
done.append(p)
|
|
return done
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Test de velocidad: descarga sola, envio solo y los dos a la vez
|
|
# ---------------------------------------------------------------------------
|
|
|
|
SPEEDTEST = {"running": False, "result": None}
|
|
|
|
|
|
def _dl_test(url, cfg, seconds, stop):
|
|
src = E.UrlSource(url).probe()
|
|
got = [0]
|
|
if not src.ranges or src.size <= 0:
|
|
gen = E._single(src.url, stop, lambda n: None)
|
|
else:
|
|
start = src.size // 3 # mitad del archivo: no siempre el principio cacheado
|
|
gen = E._ranged(src.url, start, src.size, cfg, stop, lambda n: None)
|
|
t0 = time.time()
|
|
try:
|
|
for data in gen:
|
|
got[0] += len(data)
|
|
if time.time() - t0 >= seconds or stop.is_set():
|
|
break
|
|
finally:
|
|
try:
|
|
gen.close()
|
|
except Exception:
|
|
pass
|
|
return got[0] / max(0.5, time.time() - t0)
|
|
|
|
|
|
def _up_test(cfg, seconds, stop):
|
|
path = WORK_ROOT + "/speedtest.tmp"
|
|
f = E.Ftp(cfg).connect()
|
|
try:
|
|
E.Ftp.mkdirs(f, WORK_ROOT)
|
|
conn = f.transfercmd("STOR " + path)
|
|
block = b"\0" * E.MiB
|
|
sent = 0
|
|
t0 = time.time()
|
|
with conn:
|
|
while time.time() - t0 < seconds and not stop.is_set():
|
|
conn.sendall(block)
|
|
sent += len(block)
|
|
el = time.time() - t0
|
|
try:
|
|
f.voidresp()
|
|
except Exception:
|
|
pass
|
|
try:
|
|
f.delete(path)
|
|
except Exception:
|
|
pass
|
|
return sent / max(0.5, el)
|
|
finally:
|
|
try:
|
|
f.quit()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def run_speedtest(url, seconds=10):
|
|
"""Mide por separado para saber de quien es la culpa cuando va lento."""
|
|
cfg = cfg_snapshot()
|
|
res = {"url": bool(url), "dl": None, "up": None, "both_dl": None, "both_up": None, "pipe": None,
|
|
"error": None, "verdict": ""}
|
|
stop = threading.Event()
|
|
try:
|
|
if url:
|
|
res["dl"] = _dl_test(url, cfg, seconds, stop)
|
|
res["up"] = _up_test(cfg, seconds, stop)
|
|
if url:
|
|
box = {}
|
|
th = threading.Thread(target=lambda: box.update(d=_dl_test(url, cfg, seconds, stop)))
|
|
th.start()
|
|
box["u"] = _up_test(cfg, seconds, stop)
|
|
th.join()
|
|
res["both_dl"], res["both_up"] = box.get("d"), box["u"]
|
|
except Exception as e:
|
|
res["error"] = str(e)
|
|
mb = 1024 * 1024
|
|
dl, up, both = res["dl"], res["up"], res["both_up"]
|
|
v = []
|
|
if up is not None:
|
|
v.append("PC -> PS5 solo: %.1f MB/s." % (up / mb))
|
|
if up < 6 * mb:
|
|
v.append("Es bajo: el cuello es el Wi-Fi/cable entre PC y PS5 o el FTP de la consola.")
|
|
if dl is not None:
|
|
v.append("Descarga sola desde ese enlace: %.1f MB/s." % (dl / mb))
|
|
if dl < 5 * mb:
|
|
v.append("Es bajo: el alojamiento te esta dando poca velocidad ahora mismo "
|
|
"(limite de cuenta gratis, enlace castigado o servidor lento). No es tu red.")
|
|
if dl and up and both is not None and res["both_dl"] is not None:
|
|
ideal = 1 / (1 / dl + 1 / up)
|
|
pipe = min(both, res["both_dl"]) # lo que llegaria de verdad descargando y enviando
|
|
res["pipe"] = pipe
|
|
v.append("Las dos cosas a la vez: en la practica llegarian unos %.1f MB/s a la PS5." % (pipe / mb))
|
|
if dl >= 5 * mb:
|
|
# solo tiene sentido cuando el enlace no es el cuello de botella
|
|
v.append("Con una sola radio Wi-Fi lo maximo esperable seria unos %.1f MB/s." % (ideal / mb))
|
|
if dl < 5 * mb:
|
|
v.append("Aqui manda el alojamiento: mientras de tan poca velocidad, nada de tu lado "
|
|
"lo va a mejorar.")
|
|
elif pipe < 0.6 * ideal:
|
|
v.append("Estan compitiendo peor de lo normal: prueba el limite de velocidad en Ajustes "
|
|
"un poco por debajo de esa cifra, o un cable de red en el PC.")
|
|
else:
|
|
v.append("Es lo normal para una sola radio: compartir el aire tiene ese coste. "
|
|
"Solo un cable de red en el PC lo mejoraria de verdad.")
|
|
res["verdict"] = " ".join(v)
|
|
for k in ("dl", "up", "both_dl", "both_up", "pipe"):
|
|
if res[k] is not None:
|
|
res[k] = round(res[k] / mb, 2)
|
|
return res
|
|
|
|
|
|
def _speedtest_thread(url):
|
|
try:
|
|
SPEEDTEST["result"] = run_speedtest(url)
|
|
finally:
|
|
SPEEDTEST["running"] = False
|
|
|
|
|
|
def net_mismatch(cfg):
|
|
"""Si el PC y la PS5 parecen estar en redes distintas (p. ej. 192.168.50.x y 192.168.1.x), lo explica."""
|
|
host = E.clean_host(cfg.get("ps5_ip") or "")[0]
|
|
if not re.match(r"^\d+\.\d+\.\d+\.\d+$", host or ""):
|
|
return ""
|
|
pc = F.lan_ip(host)
|
|
if not pc or pc.rsplit(".", 1)[0] == host.rsplit(".", 1)[0]:
|
|
return ""
|
|
return ("Tu PC está en la red %s.x y la PS5 en la %s.x: parecen redes distintas (dos routers, la Wi-Fi de "
|
|
"invitados o una VPN). Conecta los dos al mismo router o a la misma Wi-Fi; si cambia la IP de la PS5, "
|
|
"ponla otra vez en Ajustes." % (pc.rsplit(".", 1)[0], host.rsplit(".", 1)[0]))
|
|
|
|
|
|
SLOW_MIN = 2 * 1024 * 1024 # por debajo de 2 MB/s no se vigila (no hay caida que avisar)
|
|
|
|
|
|
def speed_watch():
|
|
"""Avisa si la velocidad hacia la PS5 cae de golpe y no se recupera. Lo tipico: la PS5 lleva un rato sin
|
|
que nadie toque el mando y baja el ritmo; al usar su menu vuelve a ir rapida."""
|
|
hist = {}
|
|
while True:
|
|
time.sleep(5)
|
|
now = time.time()
|
|
try:
|
|
with LOCK:
|
|
live = [(j["id"], float(j.get("speed") or 0), j.get("title") or "") for j in JOBS
|
|
if j.get("status") == "enviando" and j.get("pc_step") not in ("bajar", "convertir")]
|
|
ids = set()
|
|
for jid, sp, title in live:
|
|
ids.add(jid)
|
|
h = hist.setdefault(jid, {"s": [], "alert": False})
|
|
h["s"].append((now, sp))
|
|
h["s"] = [x for x in h["s"] if now - x[0] <= 300]
|
|
old = sorted(v for t, v in h["s"] if 30 <= now - t <= 300)
|
|
new = [v for t, v in h["s"] if now - t < 25]
|
|
if len(old) < 6 or len(new) < 4:
|
|
continue
|
|
before = old[int(len(old) * 0.75)] # lo que solia ir (sin picos)
|
|
after = sum(new) / len(new)
|
|
job = find(jid)
|
|
if job is None:
|
|
continue
|
|
if not h["alert"] and before >= SLOW_MIN and max(new) < before * 0.3:
|
|
h["alert"] = True
|
|
mb = lambda v: "%.1f" % (v / 1048576)
|
|
with LOCK:
|
|
job["slow"] = {"from": mb(before), "to": mb(after), "t": now}
|
|
jlog(job, "La velocidad a la PS5 ha bajado de %s a %s MB/s" % (mb(before), mb(after)))
|
|
notify("warn", "La velocidad ha bajado mucho: %s" % title,
|
|
"Ha pasado de %s a %s MB/s. Si la PS5 lleva un rato sin que nadie toque el mando, pulsa "
|
|
"un botón: cuando está inactiva va más lenta. Si no, puede ser el Wi-Fi o el servidor de "
|
|
"descarga." % (mb(before), mb(after)), {"tab": "Transfers", "job": jid},
|
|
key="slow:%s:%d" % (jid, int(now)))
|
|
elif h["alert"] and after > before * 0.6:
|
|
h["alert"] = False
|
|
with LOCK:
|
|
job.pop("slow", None)
|
|
jlog(job, "La velocidad ha vuelto a subir")
|
|
for jid in list(hist):
|
|
if jid not in ids:
|
|
hist.pop(jid, None)
|
|
j = find(jid)
|
|
if j is not None:
|
|
with LOCK:
|
|
j.pop("slow", None)
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
|
|
def health_check():
|
|
"""Revision completa: que funciona, que no y que hacer."""
|
|
cfg = cfg_snapshot()
|
|
out = []
|
|
|
|
def add(name, ok, detail, fix=""):
|
|
out.append({"name": name, "ok": ok, "detail": detail, "fix": fix})
|
|
|
|
f = None
|
|
try:
|
|
f = E.Ftp(cfg).connect()
|
|
add("FTP de la PS5", True, "%s:%s responde" % (cfg["ps5_ip"], cfg["ftp_port"]))
|
|
try:
|
|
E.Ftp.mkdirs(f, WORK_ROOT)
|
|
path = WORK_ROOT + "/prueba_escritura.tmp"
|
|
import io
|
|
f.storbinary("STOR " + path, io.BytesIO(b"x" * 65536))
|
|
ok = E.Ftp.size(f, path) == 65536
|
|
try:
|
|
f.delete(path)
|
|
except Exception:
|
|
pass
|
|
add("Escribir en la PS5", ok, "Se puede escribir en %s" % WORK_ROOT if ok else "La prueba no se guardo bien",
|
|
"" if ok else "Revisa que el servidor FTP permita escribir en /data")
|
|
except Exception as e:
|
|
add("Escribir en la PS5", False, str(e), "El FTP no deja escribir: prueba a recargar el payload FTP")
|
|
except Exception as e:
|
|
add("FTP de la PS5", False, str(e),
|
|
net_mismatch(cfg) or
|
|
"Comprueba la IP en Ajustes y que el payload FTP este cargado (puerto %s)" % cfg["ftp_port"])
|
|
finally:
|
|
try:
|
|
f and f.quit()
|
|
except Exception:
|
|
pass
|
|
exe = E.find_7z(cfg.get("sevenzip_path"))
|
|
where = cfg.get("extract_where") or "ps5"
|
|
add("7-Zip en el PC", bool(exe) or where != "pc", exe or "no instalado",
|
|
"" if exe else ("Hace falta para 'Descomprimir en el PC': instalalo desde 7-zip.org"
|
|
if where == "pc" else "Solo hace falta si eliges descomprimir en el PC"))
|
|
bf = E.BFpilot(cfg)
|
|
v = bf.alive()
|
|
add("BFpilot", bool(v), ("version %s" % v) if v else "no responde en el puerto %s" % cfg["bf_port"],
|
|
"" if v else "Cargalo desde Payload Manager: sin el no se puede descomprimir")
|
|
if v:
|
|
try:
|
|
sup = bf._req("GET", "/api/fs/archive/support")
|
|
add("Descompresion", True, "Formatos: %s" % ", ".join(sup.get("supported") or []))
|
|
except Exception as e:
|
|
add("Descompresion", False, str(e), "Actualiza BFpilot a la ultima version")
|
|
free = free_space(bf)
|
|
if free is not None:
|
|
margin = margin_bytes()
|
|
ok = free > margin + 10 * GiB
|
|
add("Espacio libre", ok, "%s libres (margen %s)" % (human(free), human(margin)),
|
|
"" if ok else "Queda poco: borra restos (Limpieza) o algo que no uses")
|
|
try:
|
|
st = bf._req("GET", "/api/fs/archive/status")
|
|
if st.get("state") in ("running", "prepared"):
|
|
add("Tarea en BFpilot", True, "Ahora mismo esta descomprimiendo: %s%%" % st.get("percent", "?"))
|
|
except Exception:
|
|
pass
|
|
exe_f = F.find_forge(cfg.get("forge_path"), DATA_DIR)
|
|
if (cfg.get("pc_format") or "folder") != "folder" or exe_f:
|
|
add("PS5 Dump Forge", True, exe_f or "se descargará solo la primera vez que lo uses",
|
|
"" if exe_f else "Hace falta para enviar como imagen .ffpkg/.ffpfsc o LZ4")
|
|
if not cfg.get("console_fw"):
|
|
add("Firmware de la PS5", True, "sin poner",
|
|
"Ponlo en Ajustes (por ejemplo 13.60) y te aviso de lo que no arrancará")
|
|
else:
|
|
add("Firmware de la PS5", True, cfg["console_fw"])
|
|
return out
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Actualizaciones: desde un .zip o desde GitHub
|
|
# ---------------------------------------------------------------------------
|
|
|
|
UPDATE_EXTS = (".py", ".html", ".txt", ".bat", ".vbs", ".sh", ".ico", ".js", ".json", ".png", ".css", ".md", ".svg")
|
|
|
|
|
|
def _ver_tuple(v):
|
|
return tuple(int(x) for x in re.findall(r"\d+", v or "0")[:4])
|
|
|
|
|
|
def _changelog(lang):
|
|
"""{version: [novedades]} sacado de LEEME.txt (es) o README_EN.txt (en)."""
|
|
fn = "README_EN.txt" if lang == "en" else "LEEME.txt"
|
|
try:
|
|
with open(os.path.join(HERE, fn), encoding="utf-8") as f:
|
|
lines = f.read().splitlines()
|
|
except Exception:
|
|
return {}
|
|
out, cur, item = {}, None, None
|
|
in_en = False
|
|
for ln in lines:
|
|
if lang == "en":
|
|
if ln.startswith("WHAT'S NEW"):
|
|
in_en = True
|
|
continue
|
|
if not in_en:
|
|
continue
|
|
if ln.strip() == "" and cur:
|
|
break
|
|
m = re.match(r"^(\d+\.\d+(?:\.\d+)?)\s+(.*)$", ln)
|
|
if m:
|
|
cur = m.group(1)
|
|
out[cur] = []
|
|
rest = m.group(2).strip()
|
|
item = None
|
|
ln = " " + rest
|
|
else:
|
|
m = re.match(r"^NOVEDADES (\d+\.\d+(?:\.\d+)?)\s*$", ln)
|
|
if m:
|
|
cur = m.group(1)
|
|
out[cur] = []
|
|
item = None
|
|
continue
|
|
if cur and ln.strip() == "":
|
|
cur = None
|
|
continue
|
|
if not cur:
|
|
continue
|
|
t = ln.strip()
|
|
if t.startswith("- "):
|
|
out[cur].append(t[2:])
|
|
elif t and out[cur]:
|
|
out[cur][-1] += " " + t
|
|
elif t:
|
|
out[cur].append(t)
|
|
return out
|
|
|
|
|
|
def whats_new(lang):
|
|
"""Novedades que ensenar tras actualizar (vacio si no toca)."""
|
|
with LOCK:
|
|
seen = SETTINGS.get("seen_version") or ""
|
|
tour_done = SETTINGS.get("tour_done")
|
|
cur = _ver_tuple(VERSION)
|
|
if seen and _ver_tuple(seen) >= cur:
|
|
return {"show": False}
|
|
if not seen:
|
|
if not tour_done: # instalacion nueva: ya ve la guia de bienvenida
|
|
with LOCK:
|
|
SETTINGS["seen_version"] = VERSION
|
|
save_settings()
|
|
return {"show": False}
|
|
# venia de una version sin este aviso: la anterior es la copia en .backup
|
|
prev = None
|
|
try:
|
|
for d in os.listdir(os.path.join(HERE, ".backup")):
|
|
if re.match(r"^\d+(\.\d+)+$", d) and _ver_tuple(d) < cur:
|
|
if prev is None or _ver_tuple(d) > _ver_tuple(prev):
|
|
prev = d
|
|
except Exception:
|
|
pass
|
|
seen = prev
|
|
log = _changelog(lang)
|
|
pad = lambda t: (t + (0, 0, 0))[:3]
|
|
entries = []
|
|
for v, items in log.items():
|
|
vt = pad(_ver_tuple(v))
|
|
if vt <= pad(cur) and (seen is None and vt[:2] == pad(cur)[:2] or seen is not None and vt > pad(_ver_tuple(seen))):
|
|
if items:
|
|
entries.append({"version": v, "items": items})
|
|
entries.sort(key=lambda e: _ver_tuple(e["version"]), reverse=True)
|
|
return {"show": bool(entries), "version": VERSION, "entries": entries[:6]}
|
|
|
|
|
|
def install_zip(data):
|
|
"""Instala una version nueva desde los bytes de un .zip. Devuelve la version instalada."""
|
|
import io
|
|
import zipfile
|
|
if busy():
|
|
raise E.PipeError("Hay trabajos en marcha: espera a que terminen o pausalos antes de actualizar")
|
|
try:
|
|
z = zipfile.ZipFile(io.BytesIO(data))
|
|
except zipfile.BadZipFile:
|
|
raise E.PipeError("Ese archivo no es un .zip valido")
|
|
names = z.namelist()
|
|
roots = [n[:-len("app.py")] for n in names if n.endswith("app.py") and (n[:-len("app.py")] + "engine.py") in names]
|
|
if not roots:
|
|
raise E.PipeError("Ese .zip no es de PS5 Directo (no trae app.py y engine.py)")
|
|
root = min(roots, key=len)
|
|
m = re.search(r'VERSION = "([^"]+)"', z.read(root + "app.py").decode("utf-8", "replace"))
|
|
if not m:
|
|
raise E.PipeError("No encuentro la version dentro del .zip")
|
|
new_ver = m.group(1)
|
|
files = []
|
|
for n in names:
|
|
if not n.startswith(root) or n.endswith("/"):
|
|
continue
|
|
rel = n[len(root):]
|
|
parts = rel.replace("\\", "/").split("/")
|
|
if not rel or rel.startswith("/") or ".." in parts or ":" in rel:
|
|
continue
|
|
if not rel.lower().endswith(UPDATE_EXTS):
|
|
continue
|
|
files.append((n, rel))
|
|
# copia de seguridad de lo que se va a reemplazar
|
|
backup = os.path.join(HERE, ".backup", VERSION)
|
|
for _, rel in files:
|
|
cur = os.path.join(HERE, *rel.split("/"))
|
|
if os.path.isfile(cur):
|
|
dst = os.path.join(backup, *rel.split("/"))
|
|
os.makedirs(os.path.dirname(dst), exist_ok=True)
|
|
with open(cur, "rb") as fi, open(dst, "wb") as fo:
|
|
fo.write(fi.read())
|
|
for n, rel in files:
|
|
dst = os.path.join(HERE, *rel.split("/"))
|
|
os.makedirs(os.path.dirname(dst), exist_ok=True)
|
|
tmp = dst + ".nuevo"
|
|
with open(tmp, "wb") as fo:
|
|
fo.write(z.read(n))
|
|
os.replace(tmp, dst)
|
|
if dst.endswith(".sh") and os.name != "nt":
|
|
os.chmod(dst, 0o755)
|
|
return new_ver
|
|
|
|
|
|
def restart_soon():
|
|
"""Arranca la version nueva y cierra esta (la nueva espera a que esta se cierre)."""
|
|
import subprocess
|
|
args = [sys.executable, os.path.join(HERE, "app.py"), "--after-update"]
|
|
kw = {"cwd": HERE}
|
|
if os.name == "nt":
|
|
kw["creationflags"] = 0x00000008 | 0x00000200 # DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP
|
|
else:
|
|
kw["start_new_session"] = True
|
|
def go():
|
|
time.sleep(0.8)
|
|
try:
|
|
subprocess.Popen(args, **kw)
|
|
finally:
|
|
os._exit(0)
|
|
threading.Thread(target=go, daemon=True).start()
|
|
|
|
|
|
def update_repo():
|
|
with LOCK:
|
|
return (SETTINGS.get("update_repo") or DEFAULT_REPO or "").strip()
|
|
|
|
|
|
def github_latest(repo):
|
|
"""(version, url_del_zip, notas) de la ultima release de GitHub."""
|
|
repo = (repo or "").strip().strip("/")
|
|
if not re.match(r"^[\w.-]+/[\w.-]+$", repo):
|
|
raise E.PipeError("Pon el repositorio como usuario/nombre en Ajustes")
|
|
req = urllib.request.Request("https://api.github.com/repos/%s/releases/latest" % repo,
|
|
headers={"User-Agent": "PS5Directo/" + VERSION,
|
|
"Accept": "application/vnd.github+json"})
|
|
with urllib.request.urlopen(req, timeout=20) as r:
|
|
j = json.load(r)
|
|
url = None
|
|
zips = [a for a in j.get("assets") or [] if a.get("name", "").lower().endswith(".zip")]
|
|
# el mas ligero primero: "without-Python" (o el normal de antes); el que trae Python, el ultimo
|
|
zips.sort(key=lambda a: (0 if "without-python" in a.get("name", "").lower() else
|
|
2 if ("portable" in a.get("name", "").lower() or "-windows.zip" in a.get("name", "").lower())
|
|
else 1))
|
|
if zips:
|
|
url = zips[0].get("browser_download_url")
|
|
url = url or j.get("zipball_url")
|
|
return (j.get("tag_name") or "").lstrip("vV"), url, (j.get("body") or "")[:12000]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Enlaces capturados por la extension del navegador
|
|
# ---------------------------------------------------------------------------
|
|
|
|
INBOX = [] # [{"url":..., "name":..., "t":...}]
|
|
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
server_version = "PS5Directo"
|
|
lan = False # True en el servidor que se abre a la red local (movil)
|
|
|
|
def log_message(self, *a):
|
|
pass
|
|
|
|
def parse_request(self):
|
|
self._t0 = time.time()
|
|
return super().parse_request()
|
|
|
|
def _send(self, code, body, ctype="application/json; charset=utf-8"):
|
|
if isinstance(body, (dict, list)):
|
|
body = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
|
elif isinstance(body, str):
|
|
body = body.encode("utf-8")
|
|
raw = len(body)
|
|
gz = (len(body) > 4096 and ctype.split(";")[0] in ("text/html", "application/json", "image/svg+xml")
|
|
and "gzip" in (self.headers.get("Accept-Encoding") or ""))
|
|
if gz:
|
|
body = gzip_cached(body)
|
|
err = ""
|
|
try:
|
|
self.send_response(code)
|
|
self.send_header("Content-Type", ctype)
|
|
self.send_header("Content-Length", str(len(body)))
|
|
if gz:
|
|
self.send_header("Content-Encoding", "gzip")
|
|
self.send_header("Vary", "Accept-Encoding")
|
|
self.send_header("Cache-Control", "no-store")
|
|
self.send_header("X-Content-Type-Options", "nosniff")
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
self.wfile.flush()
|
|
except OSError as e:
|
|
err = str(e) or e.__class__.__name__
|
|
raise
|
|
finally:
|
|
if self.lan:
|
|
lan_hit(self, code, raw, len(body), err)
|
|
|
|
def _auth(self):
|
|
if not token_ok(self.headers.get("X-Token")):
|
|
self._send(403, {"ok": False, "error": "token"})
|
|
return False
|
|
return True
|
|
|
|
def _body(self):
|
|
n = int(self.headers.get("Content-Length") or 0)
|
|
# el zip de una actualizacion va en base64 dentro del JSON: puede pasar de los 5 MB
|
|
limit = (200 if self.path.split("?")[0] == "/api/update/zip" and not self.lan else 5) * 1024 * 1024
|
|
if n > limit:
|
|
left = n # leerlo entero igualmente: si no, el navegador da "Failed to fetch"
|
|
while left > 0:
|
|
chunk = self.rfile.read(min(left, 1 << 20))
|
|
if not chunk:
|
|
break
|
|
left -= len(chunk)
|
|
return {"_too_big": True}
|
|
raw = self.rfile.read(n) if n else b"{}"
|
|
try:
|
|
return json.loads(raw.decode("utf-8"))
|
|
except ValueError:
|
|
return {}
|
|
|
|
def do_GET(self):
|
|
if self.path == "/logo.svg":
|
|
with open(os.path.join(HERE, "web", "logo.svg"), "rb") as f:
|
|
return self._send(200, f.read(), "image/svg+xml")
|
|
if self.path.startswith("/icon-") and self.path.split("?")[0].endswith(".png"):
|
|
n = re.sub(r"\D", "", self.path.split("?")[0])
|
|
fp = os.path.join(HERE, "web", "icon-%s.png" % n)
|
|
if n and os.path.isfile(fp):
|
|
with open(fp, "rb") as f:
|
|
return self._send(200, f.read(), "image/png")
|
|
if self.path.split("?")[0] == "/manifest.webmanifest":
|
|
man = {"name": "PS5 Directo", "short_name": "PS5 Directo", "display": "standalone",
|
|
"background_color": "#0f1115", "theme_color": "#0f1115", "start_url": "/",
|
|
"icons": [{"src": "/icon-%d.png?v=%s" % (n, VERSION), "sizes": "%dx%d" % (n, n),
|
|
"type": "image/png"} for n in (192, 256, 512)]}
|
|
return self._send(200, json.dumps(man).encode(), "application/manifest+json")
|
|
if self.path.split("?")[0] == "/favicon.ico":
|
|
with open(os.path.join(HERE, "web", "ps5directo.ico"), "rb") as f:
|
|
return self._send(200, f.read(), "image/x-icon")
|
|
if self.path in ("/", "/index.html") or self.path.startswith("/?"):
|
|
with open(os.path.join(HERE, "web", "index.html"), "rb") as f:
|
|
return self._send(200, f.read(), "text/html; charset=utf-8")
|
|
if self.path.split("?")[0] == "/prueba":
|
|
# pagina minima, sin token ni JavaScript: para saber si el movil llega al PC
|
|
return self._send(200, PRUEBA_HTML, "text/html; charset=utf-8")
|
|
if self.path == "/api/ext/ping":
|
|
return self._send(200, {"ok": True, "app": "PS5 Directo", "version": VERSION})
|
|
if self.path.startswith("/api/media/file?"):
|
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
|
if not token_ok((q.get("t") or [""])[0]):
|
|
return self._send(403, {"ok": False})
|
|
try:
|
|
fp, ctype = media_cached((q.get("p") or [""])[0], preview=bool((q.get("v") or [""])[0]))
|
|
except Exception as e:
|
|
return self._send(404, {"ok": False, "error": str(e)})
|
|
size = os.path.getsize(fp)
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", ctype)
|
|
self.send_header("Content-Length", str(size))
|
|
self.send_header("Cache-Control", "private, max-age=86400")
|
|
if (q.get("dl") or [""])[0]:
|
|
self.send_header("Content-Disposition", 'attachment; filename="%s"' % os.path.basename(fp))
|
|
self.end_headers()
|
|
with open(fp, "rb") as fh:
|
|
shutil_copy = __import__("shutil").copyfileobj
|
|
shutil_copy(fh, self.wfile, 1024 * 1024)
|
|
return
|
|
if self.path.startswith("/api/report/file?"):
|
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
|
if not token_ok((q.get("t") or [""])[0]):
|
|
return self._send(403, {"ok": False})
|
|
name = os.path.basename((q.get("n") or [""])[0])
|
|
fp = os.path.join(report_dir(), name)
|
|
if not name.endswith(".zip") or not os.path.isfile(fp):
|
|
return self._send(404, {"ok": False})
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/zip")
|
|
self.send_header("Content-Length", str(os.path.getsize(fp)))
|
|
self.send_header("Content-Disposition", 'attachment; filename="%s"' % name)
|
|
self.end_headers()
|
|
with open(fp, "rb") as fh:
|
|
self.wfile.write(fh.read())
|
|
return
|
|
if self.path.startswith("/api/colicon?"):
|
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
|
if not token_ok((q.get("t") or [""])[0]):
|
|
return self._send(403, {"ok": False})
|
|
data = col_icon((q.get("p") or [""])[0])
|
|
if not data:
|
|
return self._send(404, {"ok": False})
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "image/png")
|
|
self.send_header("Content-Length", str(len(data)))
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
return
|
|
if self.path.startswith("/api/cover?"):
|
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
|
if not token_ok((q.get("t") or [""])[0]):
|
|
return self._send(403, {"ok": False})
|
|
try:
|
|
data = cover_png((q.get("p") or [None])[0], (q.get("tid") or [None])[0])
|
|
except Exception:
|
|
data = None
|
|
if not data:
|
|
return self._send(404, {"ok": False})
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "image/png")
|
|
self.send_header("Content-Length", str(len(data)))
|
|
self.send_header("Cache-Control", "private, max-age=86400")
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
return
|
|
if self.path == "/api/state":
|
|
if not self._auth():
|
|
return
|
|
if self.headers.get("X-UI") and not self.lan:
|
|
UI_SEEN["t"] = time.time()
|
|
UI_SEEN["bye"] = 0.0
|
|
with LOCK:
|
|
jobs = []
|
|
for j in JOBS:
|
|
d = {k: v for k, v in j.items() if k not in ("lines", "info", "password")}
|
|
d["has_password"] = bool(j.get("password"))
|
|
d["pcx"] = (j.get("info") or {}).get("mode") == "pcx"
|
|
jobs.append(d)
|
|
st = {"ok": True, "version": VERSION, "home": HERE,
|
|
"unread": sum(1 for n in NOTIFS if not n.get("read")), "settings": dict(SETTINGS), "jobs": jobs,
|
|
"inbox": len(INBOX), "repo": SETTINGS.get("update_repo") or DEFAULT_REPO,
|
|
"sched": {"start": SCHED["start"], "after": SCHED["after"], "countdown": SCHED["countdown"]},
|
|
"lan": bool(LAN["srv"]), "remote": self.lan, "os": os.name,
|
|
"platform": sys.platform}
|
|
st["settings"].pop("ftp_pass", None)
|
|
if self.lan:
|
|
st["settings"].pop("lan_token", None)
|
|
return self._send(200, st)
|
|
self._send(404, {"ok": False})
|
|
|
|
def _from_extension(self):
|
|
o = self.headers.get("Origin") or ""
|
|
return o.startswith("chrome-extension://") or o.startswith("moz-extension://") \
|
|
or o.startswith("extension://")
|
|
|
|
def do_POST(self):
|
|
if self.path.split("?")[0] == "/api/bye":
|
|
# la ventana se esta cerrando (sendBeacon no deja poner cabeceras: token en la URL)
|
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
|
if (q.get("t") or [""])[0] == TOKEN and not self.lan:
|
|
UI_SEEN["bye"] = time.time()
|
|
return self._send(200, {"ok": True})
|
|
if self.path == "/api/ext/capture":
|
|
if self.lan or not self._from_extension():
|
|
return self._send(403, {"ok": False, "error": "solo desde la extension"})
|
|
b = self._body()
|
|
url = str(b.get("url") or "").strip()
|
|
if not re.match(r"^https?://", url, re.I) or len(url) > 4000:
|
|
return self._send(400, {"ok": False, "error": "enlace no valido"})
|
|
# cookies y navegador que usa ese alojamiento: el servidor nos dara la misma
|
|
# velocidad y el mismo permiso que al navegador (sesion, cuenta premium)
|
|
cookies = b.get("cookies") if isinstance(b.get("cookies"), dict) else {}
|
|
for u in (url, str(b.get("original") or "")):
|
|
if re.match(r"^https?://", u, re.I):
|
|
host = urllib.parse.urlparse(u).netloc.lower()
|
|
E.set_browser_headers(u, str(cookies.get(host) or ""), str(b.get("ua") or ""),
|
|
str(b.get("referrer") or ""))
|
|
with LOCK:
|
|
if not any(x["url"] == url for x in INBOX):
|
|
INBOX.append({"url": url, "name": str(b.get("name") or "")[:300], "t": time.time()})
|
|
del INBOX[:-200]
|
|
return self._send(200, {"ok": True})
|
|
if not self._auth():
|
|
return
|
|
b = self._body()
|
|
p = self.path
|
|
if self.lan:
|
|
if p in LAN_DENY:
|
|
return self._send(403, {"ok": False, "error": "Eso solo se puede hacer desde el PC"})
|
|
if p == "/api/settings":
|
|
b = {k: v for k, v in b.items() if k not in LAN_LOCKED}
|
|
if p == "/api/add":
|
|
ls = [x.strip() for x in str(b.get("lines", "")).splitlines() if x.strip()]
|
|
if any(not re.match(r"^((https?|ftp)://|magnet:\?)", x, re.I) for x in ls):
|
|
return self._send(400, {"ok": False, "error": "Desde el móvil solo se pueden añadir enlaces "
|
|
"(http, https o ftp), no archivos del PC"})
|
|
extra = extra_api(self, p, b)
|
|
if extra is not None:
|
|
return self._send(200, extra)
|
|
if p == "/api/open_ext_folder":
|
|
folder = os.path.join(HERE, "extension")
|
|
try:
|
|
F.open_path(folder)
|
|
return self._send(200, {"ok": True, "path": folder})
|
|
except Exception as e:
|
|
return self._send(200, {"ok": False, "path": folder, "error": str(e)})
|
|
if p == "/api/inbox/take":
|
|
with LOCK:
|
|
items = list(INBOX)
|
|
INBOX[:] = []
|
|
return self._send(200, {"ok": True, "items": items})
|
|
if p == "/api/update/zip":
|
|
import base64
|
|
if b.get("_too_big"):
|
|
return self._send(400, {"ok": False, "error": "El zip es demasiado grande (más de 150 MB)"})
|
|
try:
|
|
ver = install_zip(base64.b64decode(b.get("data") or ""))
|
|
except Exception as e:
|
|
return self._send(400, {"ok": False, "error": str(e)})
|
|
restart_soon()
|
|
return self._send(200, {"ok": True, "version": ver})
|
|
if p == "/api/update/check":
|
|
try:
|
|
ver, url, notes = github_latest(update_repo())
|
|
except Exception as e:
|
|
return self._send(200, {"ok": False, "error": str(e)})
|
|
if _ver_tuple(ver) > _ver_tuple(VERSION):
|
|
notify("info", "Hay una versión nueva: %s" % ver, "Pulsa Actualizar arriba para instalarla.",
|
|
{"action": "update"}, key="update:" + ver)
|
|
return self._send(200, {"ok": True, "current": VERSION, "latest": ver, "notes": notes,
|
|
"newer": _ver_tuple(ver) > _ver_tuple(VERSION)})
|
|
if p == "/api/update/github":
|
|
try:
|
|
ver, url, _ = github_latest(update_repo())
|
|
if not url:
|
|
raise E.PipeError("Esa release no tiene un .zip")
|
|
req = urllib.request.Request(url, headers={"User-Agent": "PS5Directo/" + VERSION})
|
|
with urllib.request.urlopen(req, timeout=120) as r:
|
|
data = r.read(50 * 1024 * 1024)
|
|
ver = install_zip(data)
|
|
except Exception as e:
|
|
return self._send(400, {"ok": False, "error": str(e)})
|
|
restart_soon()
|
|
return self._send(200, {"ok": True, "version": ver})
|
|
if p == "/api/whatsnew":
|
|
return self._send(200, dict(ok=True, **whats_new("en" if b.get("lang") == "en" else "es")))
|
|
if p == "/api/whatsnew/seen":
|
|
with LOCK:
|
|
SETTINGS["seen_version"] = VERSION
|
|
save_settings()
|
|
return self._send(200, {"ok": True})
|
|
if p == "/api/settings":
|
|
with LOCK:
|
|
for k, v in b.items():
|
|
if k in DEFAULTS:
|
|
if isinstance(DEFAULTS[k], bool):
|
|
v = bool(v)
|
|
elif isinstance(DEFAULTS[k], int):
|
|
try:
|
|
v = int(v)
|
|
except (TypeError, ValueError):
|
|
continue
|
|
elif isinstance(DEFAULTS[k], list):
|
|
v = [x.strip() for x in (v or []) if str(x).strip()]
|
|
if k == "ps5_ip":
|
|
# "ftp://192.168.1.50:2121", con espacios o comas: dejar solo la IP
|
|
v, port = E.clean_host(v)
|
|
if port and port != int(b.get("bf_port") or SETTINGS.get("bf_port", 5905)):
|
|
SETTINGS["ftp_port"] = port
|
|
if "ftp_port" in b:
|
|
b["ftp_port"] = port
|
|
SETTINGS[k] = v
|
|
save_settings()
|
|
return self._send(200, {"ok": True})
|
|
if p == "/api/locate":
|
|
files = b.get("files") or []
|
|
return self._send(200, {"ok": True, "found": locate_files(files)})
|
|
if p == "/api/health":
|
|
return self._send(200, {"ok": True, "checks": health_check()})
|
|
if p == "/api/places":
|
|
bf = E.BFpilot(cfg_snapshot())
|
|
try:
|
|
bases = game_bases(bf) if bf.alive() else ["/data/homebrew"]
|
|
except Exception:
|
|
bases = ["/data/homebrew"]
|
|
return self._send(200, {"ok": True, "dests": [b for b in bases if b.endswith("homebrew")]})
|
|
if p.startswith("/api/fm/") or p.startswith("/api/lib/") or p.startswith("/api/space/") or p.startswith("/api/notifs") or p.startswith("/api/gu/") or p.startswith("/api/bk/") or p.startswith("/api/col/") or p.startswith("/api/media/") or p.startswith("/api/report") or p in ("/api/pick", "/api/history", "/api/history/clear", "/api/history/redo"):
|
|
try:
|
|
return self._send(200, dict(ok=True, **fm_api(p, b)))
|
|
except E.PipeError as e:
|
|
return self._send(200, {"ok": False, "error": str(e)})
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
return self._send(200, {"ok": False, "error": str(e)})
|
|
if p == "/api/fixperms":
|
|
try:
|
|
return self._send(200, {"ok": True, "results": fix_all_perms()})
|
|
except Exception as e:
|
|
return self._send(500, {"ok": False, "error": str(e)})
|
|
if p == "/api/cleanup/scan":
|
|
try:
|
|
return self._send(200, {"ok": True, "items": cleanup_scan()})
|
|
except Exception as e:
|
|
return self._send(500, {"ok": False, "error": str(e)})
|
|
if p == "/api/cleanup/delete":
|
|
try:
|
|
return self._send(200, {"ok": True, "deleted": cleanup_delete(b.get("paths") or [])})
|
|
except Exception as e:
|
|
return self._send(500, {"ok": False, "error": str(e)})
|
|
if p == "/api/speedtest":
|
|
if SPEEDTEST["running"]:
|
|
return self._send(409, {"ok": False, "error": "Ya hay un test en marcha"})
|
|
with LOCK:
|
|
active = [j for j in JOBS if j["status"] in ("comprobando", "enviando")]
|
|
if active:
|
|
return self._send(409, {"ok": False, "error": "Pausa el envio antes del test (si no, se mezclan las medidas)"})
|
|
url = (b.get("url") or "").strip()
|
|
if url:
|
|
url = E.resolve_url(url)
|
|
SPEEDTEST.update(running=True, result=None)
|
|
threading.Thread(target=_speedtest_thread, args=(url,), daemon=True).start()
|
|
return self._send(200, {"ok": True})
|
|
if p == "/api/speedtest/result":
|
|
return self._send(200, {"ok": True, "running": SPEEDTEST["running"], "result": SPEEDTEST["result"]})
|
|
if p == "/api/test":
|
|
cfg = cfg_snapshot()
|
|
r = dict(test_connection(cfg))
|
|
if r.get("ftp") != "ok":
|
|
warn = net_mismatch(cfg)
|
|
if warn:
|
|
r["net_warn"] = warn
|
|
notify("warn", "El PC y la PS5 están en redes distintas", warn, key="net:" + warn[:60])
|
|
return self._send(200, {"ok": True, **r})
|
|
if p == "/api/add":
|
|
lines = [x.strip() for x in str(b.get("lines", "")).splitlines() if x.strip()]
|
|
if not lines:
|
|
return self._send(400, {"ok": False, "error": "Pega al menos un enlace"})
|
|
dest = (b.get("dest") or SETTINGS["dest"]).rstrip("/") or "/data/homebrew"
|
|
if not dest.startswith("/data") and not dest.startswith("/mnt/"):
|
|
return self._send(400, {"ok": False, "error": "El destino debe estar en /data o /mnt"})
|
|
job = new_job(lines, (b.get("password") or "").strip(), dest, where=b.get("where"),
|
|
raw=bool(b.get("raw")), fmt=b.get("fmt"), comp=b.get("comp"))
|
|
if "fmt" in b:
|
|
job["fmt_set"] = True
|
|
with WAKE:
|
|
JOBS.append(job)
|
|
WAKE.notify_all()
|
|
save_jobs()
|
|
return self._send(200, {"ok": True, "id": job["id"]})
|
|
if p.startswith("/api/job/"):
|
|
parts = p.split("/")
|
|
if len(parts) != 5:
|
|
return self._send(404, {"ok": False})
|
|
job_id, action = parts[3], parts[4]
|
|
with WAKE:
|
|
job = find(job_id)
|
|
if not job:
|
|
return self._send(404, {"ok": False, "error": "no existe"})
|
|
if action == "pause":
|
|
if job["status"] == "pendiente":
|
|
job["status"] = "pausado"
|
|
job["phase"] = "En pausa (pulsa Reanudar para seguir)"
|
|
elif job["status"] in ("comprobando", "enviando", "convirtiendo"):
|
|
job["_pause"] = True
|
|
CANCELS.setdefault(job_id, threading.Event()).set()
|
|
elif action == "cancel":
|
|
CANCELS.setdefault(job_id, threading.Event()).set()
|
|
if job["status"] in ("pendiente", "en cola para descomprimir"):
|
|
job["status"] = "cancelado"
|
|
job["phase"] = "Cancelado"
|
|
elif action == "decide":
|
|
choice = b.get("choice")
|
|
at_place = (job.get("ask") or {}).get("at") == "place"
|
|
job.pop("ask", None)
|
|
if choice == "cancel":
|
|
job["status"] = "cancelado"
|
|
job["phase"] = "Cancelado"
|
|
elif choice in ("send", "replace") and job["status"] in ("pausado", "error"):
|
|
job["dup_choice"] = choice
|
|
job["error"] = ""
|
|
CANCELS.setdefault(job_id, threading.Event()).clear()
|
|
if at_place and job.get("info"):
|
|
job["status"] = "en cola para descomprimir"
|
|
job["phase"] = "Colocando"
|
|
EXTRACT_Q.append(job_id)
|
|
else:
|
|
job["status"] = "pendiente"
|
|
job["phase"] = "En cola"
|
|
WAKE.notify_all()
|
|
elif action == "retry":
|
|
if job["status"] in ("error", "cancelado", "pausado"):
|
|
if b.get("password"):
|
|
job["password"] = b["password"].strip()
|
|
CANCELS.setdefault(job_id, threading.Event()).clear()
|
|
job["error"] = ""
|
|
job.pop("need_bytes", None)
|
|
job.pop("ask", None)
|
|
if job.get("info") and job.get("phase") != "Cancelado" and \
|
|
job.get("sent", 0) >= max(0, job.get("total", 0)) and job.get("total", -1) > 0:
|
|
job["status"] = "en cola para descomprimir"
|
|
job["phase"] = "Reintentando la descompresion"
|
|
EXTRACT_Q.append(job_id)
|
|
else:
|
|
job["status"] = "pendiente"
|
|
job["phase"] = "En cola"
|
|
WAKE.notify_all()
|
|
elif action == "remove":
|
|
if job["status"] in ("hecho", "error", "cancelado", "pausado"):
|
|
JOBS.remove(job)
|
|
torrent_forget(job)
|
|
elif action == "restart":
|
|
# "Descargar de nuevo": como si se volviera a pegar el enlace (trabajo nuevo, desde cero)
|
|
if job["status"] in ("hecho", "error", "cancelado"):
|
|
torrent_forget(job)
|
|
nj = new_job(list(job.get("orig_lines") or job.get("lines") or []), job.get("password") or "", job["dest"],
|
|
where=job.get("where"), raw=job.get("raw"), fmt=job.get("fmt"),
|
|
comp=job.get("comp"))
|
|
nj["fmt_set"] = job.get("fmt_set", False)
|
|
nj["title"] = job.get("title") or ""
|
|
JOBS[JOBS.index(job)] = nj
|
|
WAKE.notify_all()
|
|
elif action in ("up", "down"):
|
|
i = JOBS.index(job)
|
|
k = i - 1 if action == "up" else i + 1
|
|
if 0 <= k < len(JOBS):
|
|
JOBS[i], JOBS[k] = JOBS[k], JOBS[i]
|
|
save_jobs()
|
|
return self._send(200, {"ok": True})
|
|
if p == "/api/clear":
|
|
with LOCK:
|
|
JOBS[:] = [j for j in JOBS if j["status"] not in ("hecho", "cancelado")]
|
|
save_jobs()
|
|
return self._send(200, {"ok": True})
|
|
if p == "/api/quit":
|
|
self._send(200, {"ok": True})
|
|
threading.Thread(target=lambda: (time.sleep(0.5), os._exit(0)), daemon=True).start()
|
|
return
|
|
self._send(404, {"ok": False})
|
|
|
|
|
|
def extra_api(h, p, b):
|
|
"""Rutas de la 1.20. Devuelve el dict de respuesta o None si no es suya."""
|
|
try:
|
|
if p == "/api/payload/list":
|
|
with LOCK:
|
|
port = SETTINGS.get("elf_port") or 9021
|
|
return {"ok": True, "items": payload_list(), "elf_port": port}
|
|
if p == "/api/payload/send":
|
|
return dict(ok=True, **payload_send(pid=str(b.get("id") or "")))
|
|
if p == "/api/payload/file":
|
|
return dict(ok=True, **payload_send(path=str(b.get("path") or "")))
|
|
if p == "/api/library/scan":
|
|
library_start(bool(b.get("refresh")))
|
|
return {"ok": True}
|
|
if p == "/api/library/state":
|
|
with LOCK:
|
|
return {"ok": True, "lib": dict(LIB)}
|
|
if p == "/api/library/cancel":
|
|
LIB_CANCEL.set()
|
|
return {"ok": True}
|
|
if p == "/api/diag":
|
|
cfg = cfg_snapshot()
|
|
with LOCK:
|
|
active = sum(1 for j in JOBS if j["status"] in ("comprobando", "enviando", "convirtiendo"))
|
|
return {"ok": True, "items": F.diagnose(cfg.get("ps5_ip"), cfg, SPEEDTEST.get("result"), active)}
|
|
if p == "/api/schedule":
|
|
return dict(ok=True, **sched_set(b))
|
|
if p == "/api/lan":
|
|
if "enable" in b:
|
|
with LOCK:
|
|
SETTINGS["lan_access"] = bool(b.get("enable"))
|
|
if b.get("regen"):
|
|
SETTINGS["lan_token"] = secrets.token_urlsafe(16)
|
|
save_settings()
|
|
if b.get("enable"):
|
|
if b.get("regen"):
|
|
lan_stop()
|
|
lan_start()
|
|
else:
|
|
lan_stop()
|
|
return dict(ok=True, **lan_info())
|
|
if p == "/api/lan/hits":
|
|
with LOCK:
|
|
return {"ok": True, "hits": list(LAN_HITS[-12:])}
|
|
if p == "/api/lan/firewall":
|
|
with LOCK:
|
|
port = int(SETTINGS.get("lan_port") or 8780)
|
|
if b.get("allow"):
|
|
F.firewall_allow(port)
|
|
return dict(ok=True, **F.firewall_status(port))
|
|
if p == "/api/pcspace":
|
|
import shutil
|
|
path = pc_temp_root(cfg_snapshot())
|
|
probe = path
|
|
while probe and not os.path.isdir(probe):
|
|
parent = os.path.dirname(probe)
|
|
if parent == probe:
|
|
break
|
|
probe = parent
|
|
try:
|
|
free = shutil.disk_usage(probe or path).free
|
|
except OSError:
|
|
free = None
|
|
return {"ok": True, "path": path, "free": free}
|
|
if p == "/api/forge/status":
|
|
exe = F.find_forge(cfg_snapshot().get("forge_path"), DATA_DIR)
|
|
return {"ok": True, "path": exe or "", "found": bool(exe)}
|
|
if p == "/api/forge/download":
|
|
exe, tag = F.download_forge(DATA_DIR, log=print)
|
|
return {"ok": True, "path": exe, "tag": tag}
|
|
except E.PipeError as e:
|
|
return {"ok": False, "error": str(e)}
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
return {"ok": False, "error": str(e)}
|
|
return None
|
|
|
|
|
|
SKIP_DIRS = {"windows", "program files", "program files (x86)", "programdata", "appdata",
|
|
"$recycle.bin", "system volume information", "node_modules", ".git",
|
|
"msocache", "recovery", "$windows.~bt", "$windows.~ws", "perflogs"}
|
|
|
|
|
|
def _search_roots():
|
|
home = os.path.expanduser("~")
|
|
roots = []
|
|
for sub in ("Downloads", "Descargas", "Desktop", "Escritorio", "Documents",
|
|
"Documentos", "Videos", "Vídeos", ""):
|
|
d = os.path.join(home, sub) if sub else home
|
|
if os.path.isdir(d) and d not in roots:
|
|
roots.append(d)
|
|
if os.name == "nt":
|
|
import string
|
|
for letter in string.ascii_uppercase:
|
|
d = letter + ":\\"
|
|
if os.path.isdir(d):
|
|
roots.append(d)
|
|
else:
|
|
roots.append("/")
|
|
return roots
|
|
|
|
|
|
def locate_files(files, budget=12.0, max_depth=6):
|
|
"""Busca en el PC archivos por nombre y tamano (los que se sueltan en el navegador)."""
|
|
want = {}
|
|
for f in files:
|
|
try:
|
|
want.setdefault(str(f["name"]).lower(), []).append(int(f["size"]))
|
|
except Exception:
|
|
pass
|
|
found = {}
|
|
t0 = time.time()
|
|
seen = set()
|
|
for root in _search_roots():
|
|
stack = [(root, 0)]
|
|
while stack and len(found) < len(want):
|
|
if time.time() - t0 > budget:
|
|
return found
|
|
path, depth = stack.pop()
|
|
key = os.path.normcase(path)
|
|
if key in seen:
|
|
continue
|
|
seen.add(key)
|
|
try:
|
|
with os.scandir(path) as it:
|
|
entries = list(it)
|
|
except OSError:
|
|
continue
|
|
if True:
|
|
for e in entries:
|
|
try:
|
|
if e.is_dir(follow_symlinks=False):
|
|
n = e.name.lower()
|
|
if depth < max_depth and n not in SKIP_DIRS and not n.startswith("."):
|
|
stack.append((e.path, depth + 1))
|
|
elif e.name.lower() in want and e.name not in found:
|
|
if e.stat().st_size in want[e.name.lower()]:
|
|
found[e.name] = e.path
|
|
except OSError:
|
|
pass
|
|
if len(found) >= len(want):
|
|
break
|
|
return found
|
|
|
|
|
|
PRUEBA_HTML = """<!doctype html><meta charset=utf-8><meta name=viewport content='width=device-width'>
|
|
<title>PS5 Directo - prueba</title>
|
|
<body style='font:18px system-ui,sans-serif;background:#0e1116;color:#e6edf3;padding:24px;margin:0'>
|
|
<h2 style='color:#4ade80;margin-top:0'>✔ El móvil llega a PS5 Directo</h2>
|
|
<p>La red y el firewall están bien.</p>
|
|
<p id=r style='color:#8b97a5'>Probando a descargar la página completa…</p>
|
|
<p style='color:#8b97a5;font-size:15px'>Your phone can reach PS5 Directo.</p>
|
|
<script>
|
|
var t=Date.now(),r=document.getElementById('r');
|
|
fetch('/?prueba='+t,{cache:'no-store'}).then(function(x){return x.text()}).then(function(s){
|
|
var ok=s.indexOf('</html>')>0;
|
|
r.innerHTML=ok?'✔ Página completa recibida ('+Math.round(s.length/1024)+' KB en '+((Date.now()-t)/1000).toFixed(1)+' s). Vuelve al PC y escanea el código grande.'
|
|
:'✘ La página llegó cortada ('+Math.round(s.length/1024)+' KB). Mira en el PC: Abrir en el móvil → Prueba de conexión.';
|
|
r.style.color=ok?'#4ade80':'#f87171';
|
|
}).catch(function(e){r.innerHTML='✘ No se pudo descargar la página completa: '+e;r.style.color='#f87171'});
|
|
setTimeout(function(){if(r.style.color!=='rgb(74, 222, 128)'&&r.textContent.indexOf('Probando')==0){r.innerHTML='⚠ Lleva más de 15 s descargando la página: algo la está frenando o cortando entre el PC y el móvil.';r.style.color='#fbbf24'}},15000);
|
|
</script>"""
|
|
|
|
|
|
class LanHandler(Handler):
|
|
lan = True
|
|
timeout = 60 # una conexion del movil que se queda colgada no bloquea nada
|
|
|
|
|
|
_GZ = {}
|
|
|
|
|
|
def gzip_cached(body):
|
|
"""index.html pesa ~270 KB: comprimido son ~60 KB (el movil por Wi-Fi lo nota)."""
|
|
import gzip
|
|
import hashlib
|
|
k = hashlib.sha1(body).digest()
|
|
if k not in _GZ:
|
|
if len(_GZ) > 8:
|
|
_GZ.clear()
|
|
_GZ[k] = gzip.compress(body, 6)
|
|
return _GZ[k]
|
|
|
|
|
|
def lan_hit(h, code, raw, sent, err=""):
|
|
path = urllib.parse.urlparse(h.path).path
|
|
if path.startswith("/api/") and path not in ("/api/state",) and not err and code < 400:
|
|
return # solo lo que sirve para diagnosticar
|
|
with LOCK:
|
|
if path == "/api/state" and LAN_HITS and LAN_HITS[-1]["path"] == path and not err:
|
|
LAN_HITS[-1].update(t=time.strftime("%H:%M:%S"), n=LAN_HITS[-1].get("n", 1) + 1, code=code)
|
|
return
|
|
LAN_HITS.append({"t": time.strftime("%H:%M:%S"), "ip": h.client_address[0], "path": path, "code": code,
|
|
"bytes": raw, "sent": sent, "ms": int((time.time() - getattr(h, "_t0", time.time())) * 1000),
|
|
"err": err, "ua": (h.headers.get("User-Agent") or "")[:160]})
|
|
del LAN_HITS[:-30]
|
|
|
|
|
|
class Server(ThreadingHTTPServer):
|
|
"""En Windows, SO_REUSEADDR deja que DOS programas escuchen en el mismo puerto y las
|
|
peticiones se reparten al azar entre los dos ("Failed to fetch", la cola que aparece y
|
|
desaparece). Aqui el puerto es exclusivo."""
|
|
allow_reuse_address = os.name != "nt"
|
|
daemon_threads = True
|
|
|
|
def server_bind(self):
|
|
if os.name == "nt" and hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
|
|
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
|
super().server_bind()
|
|
|
|
|
|
LOCK_PORT = 8776
|
|
_instance_lock = []
|
|
|
|
|
|
def take_instance_lock(wait=0.0):
|
|
"""Solo un PS5 Directo a la vez: se queda con un puerto fijo mientras funciona.
|
|
Devuelve False si otro ya lo tiene (tras esperar hasta `wait` segundos)."""
|
|
end = time.time() + wait
|
|
while True:
|
|
s = socket.socket()
|
|
try:
|
|
if os.name == "nt" and hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
|
|
s.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
|
s.bind(("127.0.0.1", LOCK_PORT))
|
|
_instance_lock.append(s)
|
|
return True
|
|
except OSError:
|
|
s.close()
|
|
if time.time() >= end:
|
|
return False
|
|
time.sleep(0.25)
|
|
|
|
|
|
def pick_port():
|
|
for port in (8777, 8778, 8779, 0):
|
|
s = socket.socket()
|
|
try:
|
|
if os.name == "nt" and hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
|
|
s.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
|
s.bind(("127.0.0.1", port))
|
|
p = s.getsockname()[1]
|
|
s.close()
|
|
return p
|
|
except OSError:
|
|
s.close()
|
|
return 0
|
|
|
|
|
|
SESSION_FILE = os.path.join(DATA_DIR, "session.json")
|
|
|
|
|
|
def dropped_paths():
|
|
"""Rutas de archivos arrastrados sobre el .bat o enviados con 'Enviar a'."""
|
|
out = []
|
|
for a in sys.argv[1:]:
|
|
if a.startswith("--"):
|
|
continue
|
|
a = a.strip().strip('"')
|
|
if os.path.isfile(a) or os.path.isdir(a):
|
|
out.append(os.path.abspath(a))
|
|
return out
|
|
|
|
|
|
def running_session(full=False):
|
|
"""Devuelve (url_base, token) si ya hay un PS5 Directo funcionando
|
|
(con full=True, (url_base, token, estado))."""
|
|
try:
|
|
with open(SESSION_FILE, encoding="utf-8") as f:
|
|
ses = json.load(f)
|
|
base = "http://127.0.0.1:%d" % int(ses["port"])
|
|
req = urllib.request.Request(base + "/api/state", headers={"X-Token": ses["token"]})
|
|
with urllib.request.urlopen(req, timeout=3) as r:
|
|
st = json.load(r)
|
|
return (base, ses["token"], st) if full else (base, ses["token"])
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def replace_other_version(ses):
|
|
"""Si lo que ya esta abierto es OTRA version (o la de otra carpeta, por ejemplo una copia
|
|
vieja del escritorio) y no tiene nada en marcha, la cierra para abrir esta.
|
|
Devuelve True si se cerro."""
|
|
base, token, st = ses
|
|
if st.get("version") == VERSION and st.get("home", HERE) == HERE:
|
|
return False
|
|
for j in st.get("jobs") or []:
|
|
if j.get("status") not in ("hecho", "error", "cancelado", "pausado"):
|
|
return False # esta trabajando: no se le corta
|
|
try:
|
|
req = urllib.request.Request(base + "/api/quit", data=b"{}",
|
|
headers={"X-Token": token, "Content-Type": "application/json"})
|
|
urllib.request.urlopen(req, timeout=5).read()
|
|
except Exception:
|
|
pass
|
|
for _ in range(40):
|
|
time.sleep(0.25)
|
|
if not running_session():
|
|
print("Cerrada la version %s que seguia abierta" % st.get("version", "antigua"))
|
|
return True
|
|
return False
|
|
|
|
|
|
def forward_to_running(ses, paths):
|
|
base, token = ses
|
|
try:
|
|
req = urllib.request.Request(base + "/api/add",
|
|
data=json.dumps({"lines": "\n".join(paths)}).encode(),
|
|
headers={"X-Token": token, "Content-Type": "application/json"})
|
|
with urllib.request.urlopen(req, timeout=5) as r:
|
|
return json.load(r).get("ok", False)
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _find_app_browser():
|
|
"""Edge o Chrome (o Chromium/Brave), para abrir la app en su propia ventana sin pestañas."""
|
|
import shutil
|
|
cands = []
|
|
if os.name == "nt":
|
|
for env in ("PROGRAMFILES(X86)", "PROGRAMFILES", "LOCALAPPDATA"):
|
|
root = os.environ.get(env)
|
|
if root:
|
|
cands.append(os.path.join(root, "Microsoft", "Edge", "Application", "msedge.exe"))
|
|
cands.append(os.path.join(root, "Google", "Chrome", "Application", "chrome.exe"))
|
|
elif sys.platform == "darwin":
|
|
for base in ("/Applications", os.path.expanduser("~/Applications")):
|
|
for app, exe in (("Google Chrome", "Google Chrome"), ("Microsoft Edge", "Microsoft Edge"),
|
|
("Brave Browser", "Brave Browser"), ("Chromium", "Chromium")):
|
|
cands.append(os.path.join(base, app + ".app", "Contents", "MacOS", exe))
|
|
else:
|
|
for n in ("google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge",
|
|
"microsoft-edge-stable", "brave-browser", "brave"):
|
|
w = shutil.which(n)
|
|
if w:
|
|
cands.append(w)
|
|
for c in cands:
|
|
if os.path.isfile(c):
|
|
return c
|
|
return None
|
|
|
|
|
|
APP_USER_MODEL_ID = "PS5Directo.App"
|
|
_TITLE_RX = re.compile(r"^PS5 Directo( v[\d.]+)?$")
|
|
|
|
|
|
def _app_windows():
|
|
"""Ventanas de la interfaz (modo aplicacion de Edge/Chrome). En una pestaña normal del
|
|
navegador el titulo lleva " - Microsoft Edge" detras, asi que no se confunden."""
|
|
if os.name != "nt":
|
|
return []
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
u32 = ctypes.windll.user32
|
|
found = []
|
|
proto = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
|
|
|
|
def cb(hwnd, _):
|
|
try:
|
|
if not u32.IsWindowVisible(hwnd):
|
|
return True
|
|
cls = ctypes.create_unicode_buffer(64)
|
|
u32.GetClassNameW(hwnd, cls, 64)
|
|
if cls.value != "Chrome_WidgetWin_1":
|
|
return True
|
|
buf = ctypes.create_unicode_buffer(256)
|
|
u32.GetWindowTextW(hwnd, buf, 256)
|
|
if _TITLE_RX.match(buf.value.strip()):
|
|
found.append(hwnd)
|
|
except Exception:
|
|
pass
|
|
return True
|
|
u32.EnumWindows(proto(cb), 0)
|
|
return found
|
|
|
|
|
|
def _set_window_identity(hwnd):
|
|
"""Le dice a Windows que esa ventana es "PS5 Directo" y no Edge: icono propio en la
|
|
barra de tareas, y al anclarla se ancla PS5 Directo (con su icono y su acceso)."""
|
|
import ctypes
|
|
import uuid
|
|
from ctypes import wintypes
|
|
|
|
class GUID(ctypes.Structure):
|
|
_fields_ = [("d1", ctypes.c_ulong), ("d2", ctypes.c_ushort), ("d3", ctypes.c_ushort),
|
|
("d4", ctypes.c_ubyte * 8)]
|
|
|
|
def guid(s):
|
|
b = uuid.UUID(s).bytes_le
|
|
g = GUID()
|
|
ctypes.memmove(ctypes.byref(g), b, 16)
|
|
return g
|
|
|
|
class PROPERTYKEY(ctypes.Structure):
|
|
_fields_ = [("fmtid", GUID), ("pid", ctypes.c_ulong)]
|
|
|
|
class PROPVARIANT(ctypes.Structure):
|
|
_fields_ = [("vt", ctypes.c_ushort), ("r1", ctypes.c_ushort), ("r2", ctypes.c_ushort),
|
|
("r3", ctypes.c_ushort), ("p", ctypes.c_void_p), ("p2", ctypes.c_void_p)]
|
|
|
|
fmt = "9F4C2855-9F79-4B39-A8D0-E1D42DE1D5F3" # PKEY_AppUserModel_*
|
|
vbs = os.path.join(HERE, "PS5 Directo.vbs")
|
|
wscript = os.path.join(os.environ.get("WINDIR", r"C:\Windows"), "System32", "wscript.exe")
|
|
props = []
|
|
if os.path.isfile(vbs):
|
|
props += [(2, '"%s" "%s"' % (wscript, vbs)), # RelaunchCommand
|
|
(3, os.path.join(HERE, "web", "ps5directo.ico")), # RelaunchIconResource
|
|
(4, "PS5 Directo")] # RelaunchDisplayName
|
|
props.append((5, APP_USER_MODEL_ID)) # ID (el ultimo)
|
|
|
|
shell32 = ctypes.windll.shell32
|
|
shell32.SHGetPropertyStoreForWindow.argtypes = [wintypes.HWND, ctypes.POINTER(GUID),
|
|
ctypes.POINTER(ctypes.c_void_p)]
|
|
store = ctypes.c_void_p()
|
|
iid = guid("886D8EEB-8CF2-4446-8D02-CDBA1DBDCF99") # IPropertyStore
|
|
if shell32.SHGetPropertyStoreForWindow(hwnd, ctypes.byref(iid), ctypes.byref(store)) != 0 or not store:
|
|
return False
|
|
vtbl = ctypes.cast(store, ctypes.POINTER(ctypes.POINTER(ctypes.c_void_p)))[0]
|
|
set_value = ctypes.WINFUNCTYPE(ctypes.c_long, ctypes.c_void_p, ctypes.POINTER(PROPERTYKEY),
|
|
ctypes.POINTER(PROPVARIANT))(vtbl[6])
|
|
commit = ctypes.WINFUNCTYPE(ctypes.c_long, ctypes.c_void_p)(vtbl[7])
|
|
release = ctypes.WINFUNCTYPE(ctypes.c_ulong, ctypes.c_void_p)(vtbl[2])
|
|
ok = True
|
|
try:
|
|
for pid, text in props:
|
|
key = PROPERTYKEY(guid(fmt), pid)
|
|
s = ctypes.create_unicode_buffer(text)
|
|
pv = PROPVARIANT()
|
|
pv.vt = 31 # VT_LPWSTR (SetValue hace su propia copia)
|
|
pv.p = ctypes.cast(s, ctypes.c_void_p).value
|
|
ok = set_value(store, ctypes.byref(key), ctypes.byref(pv)) == 0 and ok
|
|
commit(store)
|
|
finally:
|
|
release(store)
|
|
return ok
|
|
|
|
|
|
def taskbar_watch():
|
|
"""Pone la identidad de PS5 Directo a cada ventana nueva de la interfaz."""
|
|
done = set()
|
|
while True:
|
|
try:
|
|
for h in _app_windows():
|
|
if h not in done:
|
|
if _set_window_identity(h):
|
|
done.add(h)
|
|
except Exception as e:
|
|
print("Barra de tareas:", e)
|
|
return
|
|
time.sleep(2)
|
|
|
|
|
|
def focus_window():
|
|
"""Si la ventana ya esta abierta, la trae al frente (en vez de abrir otra). True si habia."""
|
|
if os.name != "nt":
|
|
import shutil
|
|
import subprocess
|
|
if sys.platform.startswith("linux") and shutil.which("wmctrl"):
|
|
try:
|
|
return subprocess.run(["wmctrl", "-x", "-a", "PS5Directo"], capture_output=True,
|
|
timeout=5).returncode == 0
|
|
except Exception:
|
|
return False
|
|
return False
|
|
try:
|
|
import ctypes
|
|
u32 = ctypes.windll.user32
|
|
wins = _app_windows()
|
|
if not wins:
|
|
return False
|
|
h = wins[0]
|
|
if u32.IsIconic(h):
|
|
u32.ShowWindow(h, 9) # SW_RESTORE
|
|
u32.SetForegroundWindow(h)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def open_window(url):
|
|
"""Abre la interfaz como ventana de aplicacion. Devuelve el proceso o None."""
|
|
exe = _find_app_browser()
|
|
if exe and "--browser" not in sys.argv:
|
|
import subprocess
|
|
profile = os.path.join(DATA_DIR, "ventana")
|
|
try:
|
|
args = [exe, "--app=" + url, "--user-data-dir=" + profile, "--window-size=1150,900",
|
|
"--no-first-run", "--no-default-browser-check"]
|
|
if os.name != "nt" and sys.platform != "darwin":
|
|
args.append("--class=PS5Directo") # en Linux agrupa la ventana con su icono del menu
|
|
return subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
|
|
stderr=subprocess.DEVNULL, start_new_session=os.name != "nt")
|
|
except Exception:
|
|
pass
|
|
webbrowser.open(url)
|
|
return None
|
|
|
|
|
|
def _powershell(script, timeout=30):
|
|
import subprocess
|
|
return subprocess.run(["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script],
|
|
capture_output=True, text=True, timeout=timeout,
|
|
creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
|
|
|
|
|
|
def ensure_linux_menu():
|
|
"""Linux: entrada "PS5 Directo" en el menu de aplicaciones (con su icono). Se rehace si el
|
|
programa cambia de carpeta. Tambien acepta archivos soltados encima (Exec ... %F)."""
|
|
launcher = os.path.join(HERE, "ps5directo.sh")
|
|
if not os.path.isfile(launcher):
|
|
return
|
|
try:
|
|
if not os.access(launcher, os.X_OK):
|
|
os.chmod(launcher, 0o755)
|
|
apps = os.path.join(os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share"), "applications")
|
|
fp = os.path.join(apps, "ps5directo.desktop")
|
|
q = lambda t: '"' + t.replace("\\", "\\\\").replace('"', '\\"') + '"'
|
|
body = ("[Desktop Entry]\nType=Application\nName=PS5 Directo\n"
|
|
"Comment=Descarga, convierte y envía a tu PS5\nComment[en]=Download, convert and send to your PS5\n"
|
|
"Exec=%s %%F\nIcon=%s\nTerminal=false\nCategories=Network;FileTransfer;\n"
|
|
"StartupWMClass=PS5Directo\n" % (q(launcher), os.path.join(HERE, "web", "icon-256.png")))
|
|
try:
|
|
with open(fp, encoding="utf-8") as f:
|
|
if f.read() == body:
|
|
return
|
|
except OSError:
|
|
pass
|
|
os.makedirs(apps, exist_ok=True)
|
|
with open(fp, "w", encoding="utf-8") as f:
|
|
f.write(body)
|
|
print("Entrada en el menu de aplicaciones:", fp)
|
|
except Exception as e:
|
|
print("No se pudo crear la entrada del menu:", e)
|
|
|
|
|
|
def ensure_shortcuts():
|
|
"""Acceso directo "PS5 Directo" en el escritorio y en "Enviar a", con el icono del programa.
|
|
Se crea la primera vez; despues solo se corrige si apunta a otra carpeta (una copia vieja)."""
|
|
if sys.platform.startswith("linux"):
|
|
return ensure_linux_menu()
|
|
if os.name != "nt":
|
|
return
|
|
try:
|
|
vbs = os.path.join(HERE, "PS5 Directo.vbs")
|
|
ico = os.path.join(HERE, "web", "ps5directo.ico")
|
|
if not os.path.isfile(vbs):
|
|
return
|
|
with LOCK:
|
|
first = not SETTINGS.get("shortcut_done")
|
|
q = lambda t: "'" + t.replace("'", "''") + "'"
|
|
script = (
|
|
"$w=New-Object -ComObject WScript.Shell; $first=$%s;"
|
|
"foreach($f in @([Environment]::GetFolderPath('Desktop'), [Environment]::GetFolderPath('SendTo'))){"
|
|
" $p=Join-Path $f 'PS5 Directo.lnk'; $ex=Test-Path -LiteralPath $p;"
|
|
" $l=$w.CreateShortcut($p);"
|
|
" $want='\"'+%s+'\"';"
|
|
" if($ex -and $l.Arguments -eq $want -and $l.IconLocation -like ('*'+%s+'*')){continue}"
|
|
" if(-not $ex -and -not $first){continue}"
|
|
" if($ex -and $l.Arguments -notlike '*PS5 Directo.vbs*'){continue}"
|
|
" $l.TargetPath=(Join-Path $env:WINDIR 'System32\\wscript.exe'); $l.Arguments=$want;"
|
|
" $l.WorkingDirectory=%s; $l.IconLocation=%s+',0'; $l.Description='PS5 Directo'; $l.Save();"
|
|
" 'ok '+$p }"
|
|
) % ("true" if first else "false", q(vbs), q(ico), q(HERE), q(ico))
|
|
r = _powershell(script)
|
|
if r.stdout.strip():
|
|
print("Acceso directo:", r.stdout.strip().replace("\n", " | "))
|
|
if r.returncode == 0 and first:
|
|
with LOCK:
|
|
SETTINGS["shortcut_done"] = True
|
|
save_settings()
|
|
except Exception as e:
|
|
print("No se pudo crear el acceso directo:", e)
|
|
|
|
|
|
def refresh_window_icon():
|
|
"""La ventana guarda el icono en su cache: tras actualizar se borra para que la barra
|
|
de tareas enseñe el icono actual y no el de una version vieja."""
|
|
with LOCK:
|
|
if SETTINGS.get("icon_ver") == VERSION:
|
|
return
|
|
SETTINGS["icon_ver"] = VERSION
|
|
save_settings()
|
|
prof = os.path.join(DATA_DIR, "ventana")
|
|
for sub in ("Default", ""):
|
|
for name in ("Favicons", "Favicons-journal"):
|
|
try:
|
|
os.remove(os.path.join(prof, sub, name))
|
|
except OSError:
|
|
pass
|
|
import shutil
|
|
for d in ("Web Applications", os.path.join("Default", "Web Applications")):
|
|
shutil.rmtree(os.path.join(prof, d), ignore_errors=True)
|
|
|
|
|
|
def busy():
|
|
with LOCK:
|
|
return any(j["status"] not in ("hecho", "error", "cancelado", "pausado") for j in JOBS)
|
|
|
|
|
|
UI_SEEN = {"t": 0.0, "bye": 0.0}
|
|
|
|
|
|
def watch_ui(grace=30, silent=6 * 3600):
|
|
"""Se cierra el programa cuando cierras la ventana (la ventana avisa al cerrarse) y no hay
|
|
nada en marcha. Si la ventana solo esta minimizada, el navegador la "duerme" y deja de
|
|
preguntar: eso NO cuenta como cerrada (antes el programa se apagaba y al volver salia
|
|
"Failed to fetch"). Por si el navegador se cuelga sin avisar, tras `silent` segundos
|
|
sin noticias tambien se cierra."""
|
|
while True:
|
|
time.sleep(10)
|
|
seen, bye = UI_SEEN["t"], UI_SEEN["bye"]
|
|
if busy() or not seen or LAN["srv"]:
|
|
continue
|
|
now = time.time()
|
|
if bye and bye >= seen - 1 and now - bye > grace:
|
|
os._exit(0)
|
|
if now - seen > silent:
|
|
os._exit(0)
|
|
|
|
|
|
def main():
|
|
if sys.stdout is None: # abierto sin consola (pythonw): registro a archivo
|
|
try:
|
|
os.makedirs(DATA_DIR, exist_ok=True)
|
|
sys.stdout = sys.stderr = open(os.path.join(DATA_DIR, "ps5directo.log"), "a",
|
|
encoding="utf-8", buffering=1)
|
|
except Exception:
|
|
pass
|
|
paths = dropped_paths()
|
|
if "--after-update" in sys.argv:
|
|
for _ in range(60):
|
|
if not running_session():
|
|
break
|
|
time.sleep(0.5)
|
|
ses = running_session(full=True)
|
|
if ses and replace_other_version(ses):
|
|
ses = None
|
|
if not ses and not take_instance_lock(wait=30 if "--after-update" in sys.argv else 4):
|
|
# otro PS5 Directo esta arrancando ahora mismo (doble clic, por ejemplo): uso ese
|
|
for _ in range(40):
|
|
ses = running_session(full=True)
|
|
if ses:
|
|
break
|
|
time.sleep(0.25)
|
|
if not ses:
|
|
print("Ya hay otro PS5 Directo abierto")
|
|
sys.exit(3)
|
|
if ses:
|
|
ses = ses[:2]
|
|
if paths:
|
|
forward_to_running(ses, paths)
|
|
print("Anadido a la cola de PS5 Directo (ya estaba abierto)")
|
|
elif "--browser" in sys.argv or not focus_window():
|
|
open_window(ses[0] + "/#t=" + ses[1]) # ya funcionaba: solo enseno la ventana
|
|
sys.exit(3)
|
|
load_state()
|
|
if paths:
|
|
job = new_job(paths, "", SETTINGS["dest"])
|
|
with WAKE:
|
|
JOBS.append(job)
|
|
save_jobs()
|
|
for target in (transfer_worker, extract_worker, monitor, speed_watch):
|
|
threading.Thread(target=target, daemon=True).start()
|
|
port = pick_port()
|
|
srv = Server(("127.0.0.1", port), Handler)
|
|
try:
|
|
os.makedirs(DATA_DIR, exist_ok=True)
|
|
with open(SESSION_FILE, "w", encoding="utf-8") as f:
|
|
json.dump({"port": srv.server_address[1], "token": TOKEN}, f)
|
|
except Exception:
|
|
pass
|
|
threading.Thread(target=ensure_shortcuts, daemon=True).start()
|
|
refresh_window_icon()
|
|
if SETTINGS.get("lan_access"):
|
|
try:
|
|
lan_start()
|
|
except Exception as e:
|
|
print("Acceso desde el movil:", e)
|
|
url = "http://127.0.0.1:%d/#t=%s" % (srv.server_address[1], TOKEN)
|
|
print("PS5 Directo %s" % VERSION)
|
|
print("Abre en el navegador: %s" % url)
|
|
if "--no-browser" not in sys.argv:
|
|
threading.Timer(0.5, lambda: open_window(url)).start()
|
|
threading.Thread(target=watch_ui, daemon=True).start()
|
|
if os.name == "nt":
|
|
threading.Thread(target=taskbar_watch, daemon=True).start()
|
|
try:
|
|
srv.serve_forever()
|
|
except KeyboardInterrupt:
|
|
pass
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|