Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
94 changes: 79 additions & 15 deletions app_bureau.py
Original file line number Diff line number Diff line change
Expand Up @@ -14,9 +14,12 @@

import os
import socket
import sys
import threading
import time
import urllib.error
import urllib.request
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

import webview
Expand All @@ -25,6 +28,45 @@
# l'ouverture de la fenêtre de tout le chargement du serveur.
PORT_PREFERE = 8765

# Un démarrage lent n'est pas une panne : tant que le fil du serveur travaille, on attend
# (vécu : plus de 30 s quand iCloud Drive doit rapatrier les fichiers du programme).
DELAI_DEMARRAGE = 300
# Au-delà, la page d'attente explique pourquoi c'est plus long que d'habitude.
DELAI_AVANT_MESSAGE = 6
DOSSIER_PROGRAMME = Path(__file__).resolve().parent


def _prerecuperer_fichiers(dossier=DOSSIER_PROGRAMME):
"""Lit en parallèle les fichiers du programme (.py, .pyc de ce Python, static/) avant
qu'ils servent. Retourne le nombre de fichiers lus.

Un dossier synchronisé par iCloud Drive avec « Optimiser le stockage » voit macOS retirer
du disque les fichiers peu utilisés : chacun revient à sa première lecture, en 1 à 2 s,
et l'import de serveur.py les lit un par un (vécu : plus de 30 s). Lus tous ensemble, ils
reviennent en quelques secondes. Partout ailleurs, cette lecture de petits fichiers déjà
sur le disque ne coûte que quelques millisecondes. Ne lève jamais d'exception."""
dossier = Path(dossier)
try:
fichiers = list(dossier.glob("*.py"))
if sys.implementation.cache_tag: # « cpython-313 » : seuls les .pyc de ce Python servent
fichiers += dossier.glob(f"__pycache__/*.{sys.implementation.cache_tag}.pyc")
fichiers += (f for f in (dossier / "static").rglob("*") if f.is_file())
except OSError:
return 0

def lire(chemin):
try:
with open(chemin, "rb") as fichier:
while fichier.read(1 << 20):
pass
except OSError:
pass # illisible : l'import dira lui-même ce qui ne va pas

# Mesuré sur iCloud Drive : 64 lectures simultanées rapatrient ~16 fichiers/s, 16 en rapatrient ~12/s.
with ThreadPoolExecutor(max_workers=64) as executeur:
list(executeur.map(lire, fichiers))
return len(fichiers)


def _port_libre():
"""Réserve un port local pour le serveur interne - de préférence toujours
Expand All @@ -46,26 +88,37 @@ def _port_libre():
return port


def _attendre_serveur(url, delai=30, erreurs=()):
"""Attend que le serveur interne réponde ; s'arrête aussitôt si son démarrage a
échoué (`erreurs` : la liste remplie par _demarrer_serveur)."""
limite = time.monotonic() + delai
while time.monotonic() < limite and not erreurs:
def _attendre_serveur(url, delai=DELAI_DEMARRAGE, erreurs=(), fil=None, patience=None):
"""Attend que le serveur interne réponde. S'arrête aussitôt si son démarrage a échoué
(`erreurs` : la liste remplie par _demarrer_serveur) ou si son fil `fil` s'est arrêté ;
appelle `patience()` une fois si l'attente dépasse DELAI_AVANT_MESSAGE secondes."""
debut = time.monotonic()
while time.monotonic() - debut < delai and not erreurs:
# Avant chaque tentative : sous Windows, un port fermé n'est pas refusé tout de suite
# (la connexion va jusqu'à son délai), il ne faut pas attendre pour un fil déjà arrêté.
if fil is not None and not fil.is_alive():
return False
try:
with urllib.request.urlopen(url + "/api/valeurs", timeout=1):
return True
except urllib.error.HTTPError:
return True # il répond, même par une erreur : l'interface l'affichera mieux
except OSError:
if patience is not None and time.monotonic() - debut >= DELAI_AVANT_MESSAGE:
patience()
patience = None
time.sleep(0.05)
return False


def _demarrer_serveur(port):
"""Sauvegarde la base puis charge et lance le serveur interne, dans un fil à part.
Retourne la liste où une erreur de démarrage est déposée (import impossible...)."""
Retourne ce fil et la liste où une erreur de démarrage est déposée (import impossible...)."""
erreurs = []

def servir():
try:
_prerecuperer_fichiers()
import sauvegarde

# Sauvegarde automatique à chaque lancement (rotation), avant toute requête.
Expand All @@ -79,8 +132,9 @@ def servir():
except Exception as erreur:
erreurs.append(erreur)

threading.Thread(target=servir, daemon=True).start()
return erreurs
fil = threading.Thread(target=servir, daemon=True)
fil.start()
return fil, erreurs


def _fond_systeme():
Expand All @@ -96,9 +150,10 @@ def _fond_systeme():
return "#f7f7f5"


def _page_attente(erreur=None):
"""Page affichée pendant le chargement du serveur (le logo seul, sans texte à traduire),
ou le message d'erreur si le serveur n'a pas pu démarrer. Couleurs de static/style.css."""
def _page_attente(erreur=None, patience=False):
"""Page affichée pendant le chargement du serveur (le logo seul, sans texte à traduire ;
avec `patience`, l'explication d'un démarrage plus long que d'habitude), ou le message
d'erreur si le serveur n'a pas pu démarrer. Couleurs de static/style.css."""
import html

message = ""
Expand All @@ -107,6 +162,12 @@ def _page_attente(erreur=None):
"<p>Azimut n'a pas pu démarrer. / Azimut could not start.</p>"
f"<pre>{html.escape(str(erreur) or type(erreur).__name__)}</pre>"
)
elif patience:
message = (
"<p>Démarrage plus long que d'habitude… / Starting takes longer than usual…</p>"
"<pre>Azimut récupère ses fichiers (iCloud Drive, par exemple).\n"
"Azimut is fetching its files (iCloud Drive, for example).</pre>"
)
return f"""<!DOCTYPE html>
<html><head><meta charset="utf-8"><style>
:root {{ color-scheme: light dark; --page: #f7f7f5; --encre: #16161a; --accent: #2a78d6; }}
Expand Down Expand Up @@ -266,10 +327,13 @@ def _proposer_dossier_au_premier_lancement():
ApiBureau().choisir_dossier_donnees()


def _apres_ouverture(fenetre, url, erreurs):
def _apres_ouverture(fenetre, url, fil, erreurs):
"""Fil lancé avec la fenêtre : dès que le serveur répond, l'interface remplace la page
d'attente, puis les tâches de fond démarrent."""
if not _attendre_serveur(url, erreurs=erreurs):
def patience():
fenetre.load_html(_page_attente(patience=True))

if not _attendre_serveur(url, erreurs=erreurs, fil=fil, patience=patience):
fenetre.load_html(_page_attente(
erreurs[0] if erreurs else "Le serveur interne ne répond pas. / The internal server does not respond."
))
Expand All @@ -283,7 +347,7 @@ def _apres_ouverture(fenetre, url, erreurs):
def principal():
port = _port_libre()
url = f"http://127.0.0.1:{port}"
erreurs = _demarrer_serveur(port)
fil, erreurs = _demarrer_serveur(port)

_habiller_application_macos()
# Autorise les téléchargements (export Excel, fiche .md) depuis la fenêtre.
Expand All @@ -297,7 +361,7 @@ def principal():
background_color=_fond_systeme(),
js_api=ApiBureau(url),
)
webview.start(_apres_ouverture, (fenetre, url, erreurs), debug=False)
webview.start(_apres_ouverture, (fenetre, url, fil, erreurs), debug=False)


if __name__ == "__main__":
Expand Down
91 changes: 91 additions & 0 deletions tests/test_pont_bureau.py
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@
import threading
import unittest
from pathlib import Path
from unittest import mock
from unittest.mock import MagicMock

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
Expand Down Expand Up @@ -187,6 +188,96 @@ def test_attente_s_arrete_des_qu_un_demarrage_echoue(self):
self.assertFalse(app_bureau._attendre_serveur("http://127.0.0.1:9", delai=5, erreurs=[ImportError("x")]))
self.assertLess(time.monotonic() - debut, 1)

def test_attente_s_arrete_si_le_fil_du_serveur_est_termine(self):
import threading
import time

import app_bureau

fil = threading.Thread(target=lambda: None)
fil.start()
fil.join()
# Vécu en CI Windows : un port fermé n'y est pas refusé tout de suite, chaque tentative
# va jusqu'à son délai (1 s). Un fil déjà arrêté ne doit donc déclencher aucune tentative.
with mock.patch.object(app_bureau.urllib.request, "urlopen") as urlopen:
debut = time.monotonic()
self.assertFalse(app_bureau._attendre_serveur("http://127.0.0.1:9", delai=5, fil=fil))
self.assertLess(time.monotonic() - debut, 1)
urlopen.assert_not_called()

def test_demarrage_lent_n_est_pas_une_panne(self):
"""Vécu : iCloud rapatriait les fichiers du programme, le serveur a mis plus de 30 s -
l'ancienne attente abandonnait et laissait « ne répond pas » alors qu'il démarrait."""
import threading
import time

import app_bureau

self.assertGreaterEqual(app_bureau.DELAI_DEMARRAGE, 120)
arret = threading.Event()
fil = threading.Thread(target=arret.wait) # un serveur qui charge encore
fil.start()
self.addCleanup(arret.set)
appels = []
with mock.patch.object(app_bureau, "DELAI_AVANT_MESSAGE", 0.1):
debut = time.monotonic()
self.assertFalse(app_bureau._attendre_serveur(
"http://127.0.0.1:9", delai=0.5, fil=fil, patience=lambda: appels.append(1)))
self.assertGreaterEqual(time.monotonic() - debut, 0.5) # a attendu, fil vivant
self.assertEqual(appels, [1]) # l'explication n'est affichée qu'une fois

def test_un_serveur_qui_repond_par_une_erreur_http_est_demarre(self):
import urllib.error

import app_bureau

erreur = urllib.error.HTTPError("http://127.0.0.1:9/api/valeurs", 500, "Erreur", {}, None)
with mock.patch.object(app_bureau.urllib.request, "urlopen", side_effect=erreur):
self.assertTrue(app_bureau._attendre_serveur("http://127.0.0.1:9", delai=1))

def test_page_de_patience(self):
import app_bureau

self.assertIn("plus long que d'habitude", app_bureau._page_attente(patience=True))
self.assertNotIn("plus long", app_bureau._page_attente())
self.assertIn("pas pu démarrer", app_bureau._page_attente(ValueError("x"), patience=True))

def test_prerecuperation_lit_les_fichiers_du_programme(self):
import sys
import tempfile
from pathlib import Path

import app_bureau

with tempfile.TemporaryDirectory() as dossier:
racine = Path(dossier)
(racine / "serveur.py").write_text("x = 1\n")
(racine / "base.db").write_bytes(b"jamais lue")
(racine / "__pycache__").mkdir()
(racine / "__pycache__" / f"serveur.{sys.implementation.cache_tag}.pyc").write_bytes(b"...")
(racine / "__pycache__" / "serveur.cpython-27.pyc").write_bytes(b"...")
(racine / "static" / "langues").mkdir(parents=True)
(racine / "static" / "app.js").write_text("")
(racine / "static" / "langues" / "fr.js").write_text("")
lus = []
vrai_open = open

def open_espion(chemin, *args, **kwargs):
lus.append(Path(chemin).name)
return vrai_open(chemin, *args, **kwargs)

with mock.patch("builtins.open", open_espion):
self.assertEqual(app_bureau._prerecuperer_fichiers(racine), 4)
self.assertEqual(sorted(lus), sorted([
"serveur.py", f"serveur.{sys.implementation.cache_tag}.pyc", "app.js", "fr.js"]))

def test_prerecuperation_ne_leve_jamais(self):
import app_bureau

self.assertEqual(app_bureau._prerecuperer_fichiers("/dossier/qui/n/existe/pas"), 0)
with mock.patch("builtins.open", side_effect=PermissionError("refusé")):
app_bureau._prerecuperer_fichiers() # fichiers illisibles : rien ne remonte


if __name__ == "__main__":
unittest.main()
Loading