#!/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:///pub/devel ; 4. affiche stdout/stderr de l'application jusqu'à sa fermeture (ou Ctrl+C). Usage : tools/deploy.py [--box 192.168.0.21] [--server media.example.com] [--user nom[:mdp]] [--entry main] [--verbose] [--log deploy.log] --server : l'app ajoute ce serveur au démarrage (utile car la box n'enregistre rien en mode développement). --user nom[:mot_de_passe] : compte proposé sur « Qui regarde ? » (le mot de passe transite en clair sur le réseau local). 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] DEV_CONFIG_PATH = "/dev-config.json" class QuietHandler(http.server.SimpleHTTPRequestHandler): verbose = False dev_config = None # dict servi sur DEV_CONFIG_PATH (jamais écrit sur disque) def do_GET(self): if self.path.split("?")[0] == DEV_CONFIG_PATH and self.dev_config is not None: body = json.dumps(self.dev_config).encode() self.send_response(200) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) return super().do_GET() def log_message(self, fmt, *args): if self.verbose: sys.stderr.write("[http] %s\n" % (fmt % args)) def serve_project(bind_ip, verbose, dev_config=None): QuietHandler.verbose = verbose QuietHandler.dev_config = dev_config 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("--server", action="append", default=[], metavar="ADRESSE", help="serveur Jellyfin ajouté automatiquement par l'app au démarrage " "(ex. media.stilobique.com ; option répétable)") parser.add_argument("--user", action="extend", nargs="+", default=[], metavar="NOM[:MOT_DE_PASSE]", help="compte(s) affiché(s) sur l'écran « Qui regarde ? » ; avec mot de passe, " "connexion en un clic (ex. --user alice:mdp bob, ou --user répété)") 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 .") print("Player : %s" % box) try: me = local_ip_towards(box) except OSError as error: sys.exit("Impossible de joindre %s:80 (%s)." % (box, error)) users = [] for spec in args.user: name, sep, password = spec.partition(":") users.append({"name": name, "password": password} if sep else {"name": name}) dev_config = {"servers": args.server, "users": users} if (args.server or users) else None server = serve_project(me, args.verbose, dev_config) port = server.server_address[1] manifest_url = "http://%s:%d/manifest.json" % (me, port) print("Projet servi sur %s" % manifest_url) if args.server: print("Serveurs de test proposés à l'app : %s" % ", ".join(args.server)) if users: # les mots de passe ne sont jamais affichés print("Utilisateurs de test : %s" % ", ".join( u["name"] + (" (mot de passe fourni)" if "password" in u else "") for u in users)) 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()