Make the app view fonctional

This commit is contained in:
stilobique committed 2026-11-08 11:00:17 +01:00
1 parent e99e5bf6b4
commit f6462f05b8
24 files changed
+270 -27

No files matched your search

+182
View File
@@ -0,0 +1,182 @@
#!/usr/bin/env python3
"""Lance l'application sur un Freebox Player en mode développeur.
Reproduit le « Run » du plugin QtCreator Freebox (github.com/fbx/freebox-qtcreator-plugin) :
1. trouve le Player sur le réseau local (SSDP, type « fbx:devel ») ou utilise --box ;
2. sert le dossier du projet en HTTP (le Player y télécharge manifest.json et les QML) ;
3. appelle la méthode JSON-RPC « debug_qml_app » sur http://<box>/pub/devel ;
4. affiche stdout/stderr de l'application jusqu'à sa fermeture (ou Ctrl+C).
Usage : tools/deploy.py [--box 192.168.0.21] [--entry main] [--verbose] [--log deploy.log]
La sortie est aussi écrite dans deploy.log (racine du projet), écrasé à chaque lancement.
"""
import argparse
import functools
import http.server
import json
import os
import selectors
import socket
import sys
import threading
import time
import urllib.request
PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SSDP_ADDR = ("239.255.255.250", 1900)
SSDP_TYPE = "fbx:devel"
def discover(timeout=3.0):
"""Renvoie l'adresse IP du premier Player en mode développeur qui répond."""
request = (
"M-SEARCH * HTTP/1.1\r\n"
"HOST: 239.255.255.250:1900\r\n"
'MAN: "ssdp:discover"\r\n'
"MX: 1\r\n"
"ST: %s\r\n\r\n" % SSDP_TYPE
).encode()
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.settimeout(timeout)
try:
sock.sendto(request, SSDP_ADDR)
while True:
data, (addr, _) = sock.recvfrom(4096)
headers = data.decode(errors="replace").lower()
if "st: %s" % SSDP_TYPE in headers or "nt: %s" % SSDP_TYPE in headers:
return addr
except socket.timeout:
return None
finally:
sock.close()
def local_ip_towards(box):
"""Adresse de ce PC vue depuis le Player (interface utilisée pour le joindre)."""
with socket.create_connection((box, 80), timeout=3) as sock:
return sock.getsockname()[0]
class QuietHandler(http.server.SimpleHTTPRequestHandler):
verbose = False
def log_message(self, fmt, *args):
if self.verbose:
sys.stderr.write("[http] %s\n" % (fmt % args))
def serve_project(bind_ip, verbose):
QuietHandler.verbose = verbose
handler = functools.partial(QuietHandler, directory=PROJECT_DIR)
server = http.server.ThreadingHTTPServer((bind_ip, 0), handler)
threading.Thread(target=server.serve_forever, daemon=True).start()
return server
def json_rpc(box, method, params):
body = json.dumps({"jsonrpc": "2.0", "method": method, "params": params, "id": "0"}).encode()
request = urllib.request.Request(
"http://%s/pub/devel" % box, data=body, headers={"Content-Type": "application/json"}
)
with urllib.request.urlopen(request, timeout=15) as reply:
answer = json.load(reply)
if "error" in answer:
raise RuntimeError(answer["error"].get("message", answer["error"]))
return answer.get("result", {})
def stream_output(box, stdout_port, stderr_port):
"""Affiche la sortie de l'app ; se termine quand le Player ferme stdout (app quittée)."""
selector = selectors.DefaultSelector()
streams = {}
for port, target in ((stdout_port, sys.stdout), (stderr_port, sys.stderr)):
if port:
sock = socket.create_connection((box, port), timeout=5)
sock.settimeout(None)
selector.register(sock, selectors.EVENT_READ)
streams[sock] = target
while streams:
for key, _ in selector.select():
sock = key.fileobj
data = sock.recv(4096)
if not data:
selector.unregister(sock)
sock.close()
if streams.pop(sock) is sys.stdout:
return
continue
streams[sock].write(data.decode(errors="replace"))
streams[sock].flush()
class Tee:
"""Duplique un flux (stdout/stderr) dans le fichier de log."""
def __init__(self, stream, log):
self.stream = stream
self.log = log
def write(self, text):
self.stream.write(text)
self.stream.flush()
self.log.write(text)
self.log.flush()
def flush(self):
self.stream.flush()
self.log.flush()
def main():
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("--box", help="adresse IP du Player (sinon découverte SSDP)")
parser.add_argument("--entry", default="main", help="entry point du manifest.json (défaut : main)")
parser.add_argument("--verbose", action="store_true", help="affiche les fichiers téléchargés par le Player")
parser.add_argument("--log", default=os.path.join(PROJECT_DIR, "deploy.log"),
help="fichier de log, écrasé à chaque lancement (défaut : deploy.log ; vide pour désactiver)")
args = parser.parse_args()
if args.log:
log = open(args.log, "w", encoding="utf-8")
log.write("# deploy.py %s\n" % time.strftime("%Y-%m-%d %H:%M:%S"))
sys.stdout = Tee(sys.stdout, log)
sys.stderr = Tee(sys.stderr, log)
box = args.box
if not box:
print("Recherche d'un Freebox Player en mode développeur…")
box = discover()
if not box:
sys.exit("Aucun Player trouvé. Vérifiez le mode développeur, ou passez --box <IP>.")
print("Player : %s" % box)
try:
me = local_ip_towards(box)
except OSError as error:
sys.exit("Impossible de joindre %s:80 (%s)." % (box, error))
server = serve_project(me, args.verbose)
port = server.server_address[1]
manifest_url = "http://%s:%d/manifest.json" % (me, port)
print("Projet servi sur %s" % manifest_url)
try:
result = json_rpc(box, "debug_qml_app", {
"manifest_url": manifest_url,
"entry_point": args.entry,
"wait": False,
})
print("Application lancée. Ctrl+C pour arrêter.\n")
stream_output(box, result.get("stdout_port"), result.get("stderr_port"))
print("\nApplication fermée sur le Player.")
except KeyboardInterrupt:
print("\nArrêt.")
except Exception as error: # erreurs réseau ou JSON-RPC : message lisible
sys.exit("Échec du lancement : %s" % error)
finally:
server.shutdown()
if __name__ == "__main__":
main()