Michael/xtremflow
1
0 Fork 0
mirror of https://github.com/R0m1k3/xtremflow.git synced 2026-10-23 23:18:06 +02:00
Code Issues Packages Projects Releases Wiki Activity

Serveur réécrit en Rust

Browse Source 
Le serveur Dart (bin/) est remplacé par un serveur Rust (server/) :
tokio + axum, reqwest/rustls, SQLite embarqué via rusqlite. Même API,
mêmes routes et mêmes réponses : le front Flutter ne change pas.

La base de production est reprise telle quelle : schéma, migrations et
formats de dates (DateTime.toIso8601String de Dart) sont reproduits à
l'identique, les sessions et hachages existants restent valides.

Comportement conservé : cascade de routage, anti-SSRF, logs masqués,
rate limits, transcodage HLS/turbo.ts avec repli GPU, quotas fournisseur,
enregistrements (reprise, relances, fusion), season passes, EPG, logos de
repli, arrêt gracieux sur SIGTERM. Tests Dart portés (132 tests Rust) ;
la CI exécute fmt, test et clippy -D warnings, l'image Docker compile le
serveur dans un étage rust:1.98.1.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
MichaelandClaude Opus 5.5 committed 2026-10-13 00:29:57 +02:00
1 parent f82c70ae05
commit 3ea6fa0ae3
109 files changed
+14008 -11047
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

bin/services/logo_catalog.dart
-239
View File
@@ -1,239 +0,0 @@
import 'dart:convert';
import 'package:http/http.dart' as http;
/// Logos de chaînes de repli, tirés du dépôt public `tv-logo/tv-logos`.
///
/// POURQUOI : les URL `stream_icon` du panneau pointent chez l'hébergeur du
/// revendeur. Quand cette machine tombe — cas observé : serveur de picons en
/// maintenance, 503 sur toutes les URL —, toute la grille reste sans logo.
/// Le dépôt `tv-logos` est maintenu, nommé de façon régulière
/// (`countries/france/rmc-sport-2-fr.png`) et s'apparie au nom de chaîne.
class LogoCatalog {
LogoCatalog({
http.Client? client,
this.listingTtl = const Duration(hours: 24),
this.retryBackoff = const Duration(minutes: 15),
}) : _client = client ?? http.Client();
final http.Client _client;
/// Durée de vie d'une liste de logos par pays. L'API GitHub non
/// authentifiée plafonne à 60 requêtes par heure : une par jour suffit.
final Duration listingTtl;
/// Recul après un échec de téléchargement de liste (limite de débit,
/// réseau), pour ne pas marteler l'API à chaque tuile affichée.
final Duration retryBackoff;
final Map<String, _Listing> _listings = {};
final Map<String, Future<_Listing?>> _listingsInFlight = {};
final Map<String, DateTime> _listingFailedAt = {};
final Map<String, List<int>> _bytes = {};
/// Octets PNG du logo correspondant à [channelName], ou `null`.
Future<List<int>?> logoFor(String channelName) async {
final country = countryFolderFor(channelName);
final listing = await _listingFor(country);
if (listing == null) return null;
final key = matchLogoKey(channelName, listing.urls.keys);
if (key == null) return null;
final url = listing.urls[key]!;
final cached = _bytes[url];
if (cached != null) return cached;
try {
final response = await _client
.get(Uri.parse(url))
.timeout(const Duration(seconds: 20));
if (response.statusCode != 200) return null;
return _bytes[url] = response.bodyBytes;
} catch (_) {
return null;
}
}
Future<_Listing?> _listingFor(String country) async {
final cached = _listings[country];
if (cached != null &&
DateTime.now().difference(cached.fetchedAt) < listingTtl) {
return cached;
}
final failedAt = _listingFailedAt[country];
if (failedAt != null &&
DateTime.now().difference(failedAt) < retryBackoff) {
// Liste périmée plutôt que rien : les logos ne changent pas d'un jour
// à l'autre.
return cached;
}
// Les tuiles d'une grille arrivent en rafale : une seule requête de liste.
return _listingsInFlight[country] ??=
_fetchListing(country).whenComplete(() {
_listingsInFlight.remove(country);
});
}
Future<_Listing?> _fetchListing(String country) async {
final url = 'https://api.github.com/repos/tv-logo/tv-logos/contents/'
'countries/$country';
try {
final response = await _client.get(
Uri.parse(url),
headers: {'Accept': 'application/vnd.github+json'},
).timeout(const Duration(seconds: 20));
if (response.statusCode != 200) {
throw StateError('HTTP ${response.statusCode}');
}
final urls = <String, String>{};
final decoded = json.decode(response.body);
if (decoded is List) {
for (final entry in decoded) {
if (entry is! Map) continue;
final name = entry['name']?.toString() ?? '';
final download = entry['download_url']?.toString();
if (download == null || !name.endsWith('.png')) continue;
urls[_keyFromFileName(name)] = download;
}
}
final listing = _Listing(urls, DateTime.now());
_listings[country] = listing;
_listingFailedAt.remove(country);
print('[LogoCatalog] $country : ${urls.length} logos');
return listing;
} catch (e) {
_listingFailedAt[country] = DateTime.now();
print('[LogoCatalog] liste $country indisponible : $e');
return _listings[country];
}
}
/// `rmc-sport-2-fr.png` → `rmc-sport-2`.
static String _keyFromFileName(String name) {
final base = name.substring(0, name.length - '.png'.length);
return base.replaceFirst(RegExp(r'-[a-z]{2}$'), '');
}
}
class _Listing {
_Listing(this.urls, this.fetchedAt);
/// Clé normalisée → URL de téléchargement brute.
final Map<String, String> urls;
final DateTime fetchedAt;
}
/// Code pays du préfixe panneau → dossier du dépôt `tv-logos`.
const _countryFolders = {
'fr': 'france',
'be': 'belgium',
'ch': 'switzerland',
'uk': 'united-kingdom',
'gb': 'united-kingdom',
'us': 'united-states',
'ca': 'canada',
'de': 'germany',
'es': 'spain',
'it': 'italy',
'pt': 'portugal',
'nl': 'netherlands',
};
/// Préfixe pays des noms panneau : `FR - `, `FR: `, `|FR| `.
final _countryPrefix = RegExp(r'^\W*([A-Za-z]{2})[\s\-:|]+');
/// Dossier `tv-logos` à consulter pour [channelName]. France par défaut :
/// c'est l'audience de l'application.
String countryFolderFor(String channelName) {
final match = _countryPrefix.firstMatch(channelName);
final code = match?.group(1)?.toLowerCase();
return _countryFolders[code] ?? 'france';
}
/// Mots sans rapport avec l'identité de la chaîne : qualité, codec, variante
/// de flux. Ils sont propres au panneau et absents des noms de logos.
const _noise = {
'fhd', 'uhd', 'hd', 'sd', '4k', '8k', 'hdr', 'hevc', 'h264', 'h265',
'1080p', '720p', '50fps', 'fps', 'raw', 'backup', 'vip', 'multi',
'vf', 'vo', 'vostfr',
};
const _accents = {
'à': 'a', 'á': 'a', 'â': 'a', 'ä': 'a', 'è': 'e', 'é': 'e', 'ê': 'e',
'ë': 'e', 'ì': 'i', 'í': 'i', 'î': 'i', 'ï': 'i', 'ò': 'o', 'ó': 'o',
'ô': 'o', 'ö': 'o', 'ù': 'u', 'ú': 'u', 'û': 'u', 'ü': 'u', 'ç': 'c',
};
List<String> _tokens(String channelName) {
var name = channelName;
final prefix = _countryPrefix.firstMatch(name);
if (prefix != null &&
_countryFolders.containsKey(prefix.group(1)!.toLowerCase())) {
name = name.substring(prefix.end);
}
final folded = StringBuffer();
for (final rune in name.toLowerCase().runes) {
final char = String.fromCharCode(rune);
folded.write(_accents[char] ?? char);
}
return folded
.toString()
.replaceAll('+', ' plus ')
.replaceAll('&', ' and ')
.split(RegExp(r'[^a-z0-9]+'))
.where((t) => t.isNotEmpty && !_noise.contains(t))
.toList();
}
/// Clé de logo la plus proche de [channelName] parmi [available], ou `null`.
///
/// Par ordre de confiance : nom exact, nom sans « live », variante plus
/// longue du même identifiant (`bein-sports-1` → `bein-sports-1-french`),
/// puis la marque sans numéro de canal (`rmc-sport-live-5` → `rmc-sport-1`).
/// Aucune approximation sur un mot seul : « France » ne doit pas devenir
/// France 24.
String? matchLogoKey(String channelName, Iterable<String> available) {
final keys = available.toSet();
final tokens = _tokens(channelName);
if (tokens.isEmpty) return null;
List<String> withoutLive(List<String> parts) =>
parts.where((t) => t != 'live').toList();
String? exact(List<String> parts) {
final slug = parts.join('-');
return parts.isNotEmpty && keys.contains(slug) ? slug : null;
}
String? longerVariant(List<String> parts) {
if (parts.length < 2) return null;
final slug = parts.join('-');
final longer = keys.where((k) => k.startsWith('$slug-')).toList()
..sort((a, b) {
final byLength = a.length.compareTo(b.length);
return byLength != 0 ? byLength : a.compareTo(b);
});
return longer.isEmpty ? null : longer.first;
}
final noLive = withoutLive(tokens);
final direct = exact(tokens) ??
exact(noLive) ??
longerVariant(tokens) ??
longerVariant(noLive);
if (direct != null) return direct;
// Marque sans numéro de canal, seulement s'il reste au moins deux mots.
if (RegExp(r'^\d+$').hasMatch(tokens.last)) {
final brand = withoutLive(tokens.sublist(0, tokens.length - 1));
if (brand.length >= 2) return exact(brand) ?? longerVariant(brand);
}
return null;
}