217 lines
8.4 KiB
Python
Executable File
217 lines
8.4 KiB
Python
Executable File
#!/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] [--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 <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))
|
|
|
|
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()
|