| import json |
| """دورة الإشراف الكاملة: Source stall → watchdog → cleanup → monitor → LIVE → جلسة جديدة. |
| |
| HTTP محلي حقيقي + FFmpeg حقيقي (لا stub للعملية): الحالة المطلوب إثباتها هي «العملية حيّة |
| وتدفّقها مات»، ولا تُثبت بمحاكاة. الصمت الخالص (لا بيانات ولا إغلاق) مقيس بدقة التوقيت في |
| test_watchdog.py؛ هنا نقيس الدورة الكاملة، والخادم يُغلق بعد الصمت كما يفعل CDN حقيقي حتى |
| لا يُعلّق خادم الاختبار نفسه في write على مقبس ممتلئ. |
| """ |
| import http.server, os, pathlib, socketserver, subprocess, sys, tempfile, threading, time |
|
|
| DIR = pathlib.Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else pathlib.Path('/home/user/audit') |
| os.environ.update(DATA_DIR=str(tempfile.mkdtemp()), PASSWORD='admin', ENSURE_FREE_MB='1', MIN_FREE_MB='1') |
| sys.path.insert(0, str(DIR)) |
| from shutil import which |
| FF = which(os.environ.get('FFMPEG_PATH') or 'ffmpeg') or '/tmp/fftools/ffmpeg-7.0.2-amd64-static/ffmpeg' |
| os.environ.update(YOUTUBE_SEND_MODE='copy', YOUTUBE_SOURCE_STALL_SECONDS='3', YOUTUBE_SOURCE_READ_TIMEOUT='1', |
| YOUTUBE_PROGRESS_STALL_SECONDS='25', YOUTUBE_WATCHDOG_REPORT_SECONDS='60', FFMPEG_PATH=FF) |
| import relay |
| from relay import Sender, SourceStalled |
|
|
| tmp = pathlib.Path(tempfile.mkdtemp()) |
| _stub = tmp / 'mkvmerge' |
| _stub.write_text('#!/bin/sh\nexit 0\n') |
| _stub.chmod(0o755) |
| os.environ['MKVMERGE_PATH'] = str(_stub) |
| os.environ['FFPROBE_PATH'] = which(os.environ.get('FFPROBE_PATH') or 'ffprobe') or \ |
| '/tmp/fftools/ffmpeg-7.0.2-amd64-static/ffprobe' |
|
|
| SRC = tmp / 'src.flv' |
| subprocess.run([FF, '-hide_banner', '-loglevel', 'error', '-y', '-f', 'lavfi', |
| '-i', 'testsrc2=size=320x240:rate=20', '-f', 'lavfi', |
| '-i', 'sine=frequency=440:sample_rate=48000', '-t', '120', |
| '-map', '0:v', '-map', '1:a', '-c:v', 'libx264', '-preset', 'ultrafast', |
| '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-ar', '48000', '-ac', '1', |
| '-f', 'flv', str(SRC)], check=True, capture_output=True) |
| DATA = SRC.read_bytes() |
|
|
| state = {'mode': 'flow'} |
|
|
|
|
| class Handler(http.server.BaseHTTPRequestHandler): |
| protocol_version = 'HTTP/1.1' |
|
|
| def log_message(self, *a): |
| pass |
|
|
| def do_GET(self): |
| self.send_response(200) |
| self.send_header('Content-Type', 'video/flv') |
| self.end_headers() |
| step, pos, served = 8192, 0, 0 |
| try: |
| while True: |
| if state['mode'] == 'dead': |
| return |
| if state['mode'] == 'stall' and served < 200: |
| time.sleep(0.02) |
| continue |
| if state['mode'] == 'stall': |
| while state['mode'] == 'stall': |
| time.sleep(0.1) |
| continue |
| if state['mode'] == 'stall_close' and served >= 200: |
| return |
| self.wfile.write(DATA[pos:pos + step]) |
| self.wfile.flush() |
| time.sleep(float(os.environ.get('TEST_CHUNK_DELAY', '0.012'))) |
| served += 1 |
| pos = (pos + step) % max(step, len(DATA) - step) |
| except (BrokenPipeError, ConnectionResetError, OSError): |
| pass |
|
|
|
|
| class Server(socketserver.ThreadingTCPServer): |
| allow_reuse_address = True |
| daemon_threads = True |
| hits = [] |
|
|
| def handle_error(self, *a): |
| pass |
|
|
|
|
| srv = Server(('127.0.0.1', 0), Handler) |
| PORT = srv.server_address[1] |
| threading.Thread(target=srv.serve_forever, daemon=True).start() |
| URL = 'http://127.0.0.1:%d/stage/stream.flv' % PORT |
| CAND = {'url': URL, 'media': 'flv', 'codec': 'h264', 'label': 'hd · h264'} |
| logs = [] |
| results = [] |
|
|
|
|
| def check(tag, cond, extra=''): |
| results.append((tag, bool(cond))) |
| print(' %s %s %s' % ('OK —' if cond else 'FAIL', tag, extra)) |
|
|
|
|
| def new_sender(): |
| s = Sender(FF, lambda u, m: logs.append(str(m)), lambda u: {}) |
| s.mode_override = 'copy' |
| return s |
|
|
|
|
| |
| sender = new_sender() |
| out = tmp / 'H.flv' |
| box = {'rc': None, 'exc': None} |
| st_h = threading.Event() |
|
|
|
|
| def _h(): |
| try: |
| box['rc'] = sender.send('u', CAND, str(out), st_h) |
| except BaseException as e: |
| box['exc'] = e |
|
|
|
|
| t0 = time.monotonic() |
| t_h = threading.Thread(target=_h, daemon=True) |
| t_h.start() |
| seen = 0 |
| while time.monotonic() - t0 < 25 and sender.snapshot()['source_bytes'] < 300 * 1024: |
| time.sleep(0.1) |
| seen = sender.snapshot()['source_bytes'] |
| state['mode'] = 'stall_close' |
| t_h.join(timeout=25) |
| dur = time.monotonic() - t0 |
| snap = sender.snapshot() |
| check('H: تدفق حقيقي ثم انقطاع ⇒ الجلسة تُنهي بلا تعليق وبلا استثناء غامض', |
| (box['exc'] is None or isinstance(box['exc'], SourceStalled)) and not t_h.is_alive(), |
| 'exc=%s بعد %.1fs' % (type(box['exc']).__name__ if box['exc'] else 'None', dur)) |
| check('H: البيانات خرجت فعلًا إلى الوجهة قبل الانقطاع', |
| snap['output_seconds'] > 0 and out.stat().st_size > 10000, |
| 'out=%.1fs size=%d' % (snap['output_seconds'], out.stat().st_size)) |
| check('H: الحارس لم يقطع تدفقًا سليمًا (انتظر الانقطاع المصطنع)', seen > 8 * 8192, 'bytes=%d' % seen) |
| check('H: لا عملية ولا جلسة معلّقة بعد الإنهاء', sender.process is None and sender.session is None) |
| check('H: التنظيف موثّق بوسم [CLEANUP]', any('[CLEANUP]' in m for m in logs[-8:])) |
|
|
| |
| state['mode'] = 'flow' |
| sender2 = new_sender() |
| st2 = threading.Event() |
| res2 = {} |
| t2 = threading.Thread(target=lambda: res2.setdefault('rc', sender2.send('u', CAND, str(tmp / 'I.flv'), st2)), |
| daemon=True) |
| t2.start() |
| time.sleep(10) |
| mid = sender2.snapshot() |
| check('I: بعد عودة التدفق تعمل جلسة جديدة بلا تعديل يدوي', mid['output_seconds'] > 0, |
| 'out=%.1f src_age=%s' % (mid['output_seconds'], mid.get('source_age'))) |
| st2.set() |
| t2.join(timeout=25) |
| check('I: لا جلستان للمرسل نفسه في وقت واحد', sender2.process is None and sender2.session is None) |
|
|
| |
| os.environ['YOUTUBE_SCAN_SECONDS'] = '15' |
| import youtube_manager as ym |
| mgr = ym.ManagedYouTube(FF, lambda u, force=False: {'status': 'live', 'room_id': '7', 'sources': [CAND], |
| 'nickname': 'n', 'live_title': 'x'}, |
| lambda u, m: logs.append(str(m)), list, tmp / 'yt.json', headers_for=lambda u: {}) |
| mgr.hold_seconds = 0.0 |
| key = 'u7:7' |
| mgr.journal.change(lambda d: d['events'].update({key: { |
| 'session_key': key, 'username': 'u7', 'nickname': 'u7', 'room_id': '7', 'title': 't', 'description': 'd', |
| 'hashtags': '', 'privacy': 'public', 'marker': 'MK', 'broadcast_id': 'B', 'bound': True, 'closing': False, |
| 'phase': 'live', 'youtube_status': 'live', 'created_at': time.time(), 'was_live': True, |
| 'create_pending': False, 'note': '', 'last_poll': time.time()}})) |
| mgr.destinations['u7'] = 'rtmps://example.invalid/y' |
| |
| |
| _lifecycle_ensure_stream = mgr.ensure_stream |
| def _local_lifecycle_ingest(user): |
| mgr.destinations[user] = 'rtmps://example.invalid/y' |
| return {} |
| mgr.ensure_stream = _local_lifecycle_ingest |
| |
| |
| |
| |
| mgr.stream_health = lambda *a, **k: None |
| mgr.start_sender(key) |
| time.sleep(3) |
| entry = mgr.senders.get(key) |
| running0 = entry['sender'].alive() |
| deadline = time.monotonic() + 40 |
| while time.monotonic() < deadline and entry['sender'].alive(): |
| time.sleep(0.5) |
| stopped = not entry['sender'].alive() or not running0 |
| attended = mgr.needs_attention(key) |
| state['mode'] = 'flow' |
| seen_force = [] |
|
|
|
|
| def obs_force(u, force=False): |
| seen_force.append(bool(force)) |
| return {'status': 'live', 'room_id': '7', 'sources': [CAND], 'nickname': 'n', 'live_title': 'x'} |
|
|
|
|
| mgr.observe = obs_force |
| mgr.drive_event(key) |
| entry2 = mgr.senders.get(key) |
| time.sleep(6) |
| _snap2 = entry2['sender'].snapshot() if entry2 else {} |
| out2 = float(_snap2.get('output_seconds') or 0) |
| src2 = float(_snap2.get('source_bytes') or 0) |
| check('J: صمت المصدر أوقف الدفع ثم أعاده المدير من جديد (دورة كاملة بلا تدخّل)', |
| stopped and entry2 is not None and src2 > 0, |
| 'stop=%s بايت_المصدر=%.0f out=%.1f' % (stopped, src2, out2)) |
| check('J: out_time لا يتقدّم حين لا شيء يُسلَّم (كان timeshift يقيس المخزن لا الوجهة)', |
| out2 == 0 and src2 > 0, 'out=%.1f src=%.0f' % (out2, src2)) |
| |
| |
| watchdog_logged = any('[WATCHDOG]' in m for m in logs[-25:]) |
| check('J: عطل التدفق أُعلِن في السجل وأُعيد الرصد/الجلسة (خيط حيّ لا يحتاج قفز الكاش)', |
| watchdog_logged and bool(seen_force) and src2 > 0, |
| 'attended=%s force=%s src=%.0f log=%s' % (attended, seen_force[:2], src2, watchdog_logged)) |
| |
| |
| def _first(tag, after=-1): |
| for i in range(after + 1, len(logs)): |
| if tag in logs[i]: |
| return i |
| return -1 |
|
|
|
|
| i_restart = _first('[RESTART]') |
| i_relay = _first('[RELAY]', i_restart) |
| i_watch = _first('[WATCHDOG]', i_relay) |
| i_clean = _first('[CLEANUP]', i_watch) |
| check('J: الدورة موثّقة بترتيبها في السجل: [RESTART]→[RELAY]→[WATCHDOG]→[CLEANUP]', |
| -1 not in (i_restart, i_relay, i_watch, i_clean), |
| 'idx=%s/%s/%s/%s' % (i_restart, i_relay, i_watch, i_clean)) |
|
|
| |
| |
| try: |
| _snap = mgr.snapshot() |
| _ev0 = (_snap.get('events') or [{}])[0] |
| missing = [k for k in ('source_age_seconds', 'source_stall_limit', 'source_gap', 'output_seconds', |
| 'youtube_health', 'phase') if k not in _ev0] |
| except Exception as exc: |
| missing = ['snapshot رفع %s' % type(exc).__name__] |
| check('J: payload اللوحة فيه كل المفاتيح (لا مفتاح يبتلعه تعليق في نفس السطر)', not missing, str(missing)) |
|
|
| check('J: لا جلسة مزدوجة ولا عمليات ffmpeg متراكمة', |
| len(mgr.senders) == 1 and sum(1 for e in mgr.senders.values() if e['sender'].alive()) <= 1, |
| 'senders=%d' % len(mgr.senders)) |
|
|
| |
| mgr.observe = lambda u, force=False: {'status': 'offline', 'room_id': '7', 'sources': [], |
| 'nickname': 'n', 'live_title': ''} |
| mgr.drive_event(key) |
| ev = mgr.journal.read()['events'].get(key) |
| check('K: أول offline لا يغلق الحدث ولا يحذف المشرف (تأكيد قبل الإنهاء)', |
| (not ev or not ev.get('closing')) and key in mgr.senders) |
| _dead = time.monotonic() + 8 |
| while time.monotonic() < _dead and not any('[OFFLINE]' in m or 'TikTok offline' in m for m in logs): |
| time.sleep(0.3) |
| check('K: إشارة offline الأولى مميزة في السجل عن صمت المصدر (والإنهاء ينتظر التأكيد)', |
| any('[OFFLINE]' in m or 'TikTok offline' in m for m in logs), logs[-1][:90]) |
| for e in list(mgr.senders.values()): |
| e['stop'].set() |
| e['sender'].terminate() |
| for _lifecycle_key in list(mgr.senders): |
| mgr.stop_sender(_lifecycle_key) |
| mgr.ensure_stream = _lifecycle_ensure_stream |
|
|
| |
| r = subprocess.run([sys.executable, '-c', |
| 'import sys;sys.path.insert(0,%r);import app;print("IMPORT-OK")' % str(DIR)], |
| capture_output=True, text=True, env=dict(os.environ, RECORD_MODE='never')) |
| check('L: app.py يُستورد بلا استثناء', 'IMPORT-OK' in r.stdout, (r.stderr or '')[-140:]) |
|
|
| |
| |
| class _FakeTh: |
| def is_alive(self): return True |
| class _FakeSender: |
| stall_limit = 45 |
| def snapshot(self): return {'status': 'يرسل', 'source': 'hd', 'output_seconds': 12.0, 'source_age': 3.0} |
| _snap = _FakeSender().snapshot() |
| _payload = {'source_age_seconds': _snap.get('source_age'), 'source_stall_limit': _FakeSender.stall_limit} |
| check('L: عمر آخر بايت من المصدر يمرّ إلى حالة اللوحة', _payload['source_age_seconds'] == 3.0 |
| and _payload['source_stall_limit'] == 45, str(_payload)) |
| try: |
| mgr.senders['panel-check'] = {'sender': _FakeSender(), 'thread': _FakeTh(), 'stop': type('S', (), {'is_set': lambda self: False})()} |
| snap = mgr.snapshot() |
| check('L: snapshot المدير يعمل مع المرسلات الحيّة (لا AttributeError على stall_limit)', isinstance(snap, dict), '') |
| except Exception as exc: |
| check('L: snapshot المدير يعمل مع المرسلات الحيّة (لا AttributeError على stall_limit)', False, repr(exc)[:150]) |
| finally: |
| mgr.senders.pop('panel-check', None) |
| try: |
| from fastapi.testclient import TestClient |
| import app as appmod |
| with TestClient(appmod.app) as c: |
| r1 = c.get('/api/state', auth=('admin', 'admin')) |
| r2 = c.get('/api/youtube', auth=('admin', 'admin')) |
| check('L: نقاط الصحة/الحالة (FastAPI) تعمل', r1.status_code == 200 and r2.status_code == 200 |
| and 'version' in r1.json() and 'send_mode' in r2.json(), |
| 'state=%s youtube=%s ver=%s' % (r1.status_code, r2.status_code, r1.json().get('version'))) |
| except ImportError as e: |
| check('L: TestClient غير متاح (httpx ناقص) — فحص الاستيراد يكفي', True, str(e)[:60]) |
|
|
| |
| _src = (DIR / 'app.py').read_text(encoding='utf-8') |
| _routes = [seg.split(chr(39))[1] for seg in _src.splitlines() if seg.startswith('@app.') and chr(39) in seg] |
| check('L: FastAPI exposes minimal /health plus authenticated state/youtube diagnostics', |
| all(r in _routes for r in ('/health','/api/health','/api/state','/api/youtube')) |
| and 'flask' not in (DIR / 'requirements.txt').read_text(encoding='utf-8').lower(), |
| 'routes=%d' % len(_routes)) |
|
|
| |
| ps = subprocess.run(['ps', '-eo', 'args'], capture_output=True, text=True).stdout.splitlines() |
| stray = [l for l in ps if 'testsrc2' in l or (str(tmp) in l and 'ffmpeg' in l)] |
| |
| class _BoomSender: |
| last_exit_code = 187 |
| mgr.retry_min = 5.0 |
| mgr.retry_max = 600.0 |
| mgr.retry.clear() |
| mgr.hammer.clear() |
| logs_tail = [] |
| mgr.log = lambda u, m: logs_tail.append(str(m)) |
| for _ in range(3): |
| mgr._note_early_exit('hammeruser', _BoomSender(), lasted=4.0) |
| third = mgr._backoff('hammeruser') |
| mgr._note_early_exit('hammeruser', _BoomSender(), lasted=4.0) |
| hammered = mgr._backoff('hammeruser') |
| |
| |
| started_while_gated = 'لم يُنفَّذ' |
| gate_ok = False |
| try: |
| mgr.journal.change(lambda d: d['events'].update({'gate:key': {'username': 'hammeruser', 'room_id': '7', |
| 'broadcast_id': 'X', 'bound': True, |
| 'marker': 'm'}})) |
| mgr.hammer.clear(); mgr.retry_at.clear() |
| for _ in range(4): |
| mgr._note_early_exit('hammeruser', _BoomSender(), lasted=4.0) |
| gate_ok = mgr.retry_at.get('gate:key', 0) > time.monotonic() |
| mgr.start_sender('gate:key') |
| e = mgr.senders.get('gate:key') |
| started_while_gated = bool(e and e['thread'].is_alive()) |
| if e: |
| e['stop'].set() |
| e['sender'].terminate() |
| except Exception as exc: |
| started_while_gated = repr(exc)[:100] |
| check('N: التأجيل يقفل start_sender من tick() أيضًا (لا إعادة اتصال كل 15 ث على حافة رافضة)', |
| gate_ok and started_while_gated is False, 'gated=%s started=%s' % (gate_ok, started_while_gated)) |
|
|
| mgr.senders.pop('gate:key', None) |
| mgr.journal.change(lambda d: d['events'].pop('gate:key', None)) |
| mgr.hammer.clear(); mgr.retry_at.clear() |
|
|
| |
| _logs_gp = [] |
| mgr.log = lambda u, m: _logs_gp.append(str(m)) |
| mgr.journal.change(lambda d: d['events'].update({'gate:vis': {'username': 'visu', 'room_id': '9', |
| 'title': 't', 'note': '', 'phase': 'live', |
| 'broadcast_id': 'X', 'bound': True, 'marker': 'm'}})) |
| mgr.retry_at['gate:vis'] = time.monotonic() + 60 |
| mgr.start_sender('gate:vis') |
| noted = ('إعادة الاتصال مؤجّلة' in ((mgr.journal.read()['events'].get('gate:vis') or {}).get('note') or '')) |
| n_cleared = mgr.clear_pacing('visu', 'اختبار') |
| vis_state = {k: v for k, v in (mgr.snapshot().get('events') or [{}])[0].items() if k in ('retry_in', 'note')} |
| mgr.journal.change(lambda d: d['events'].pop('gate:vis', None)) |
| mgr.log = lambda u, m: logs.append(str(m)) |
| check('N: القفل مرئي (ملاحظة «إعادة الاتصال مؤجّلة N ث» لا صمت) وقابل للإلغاء بقرار المشغّل', |
| noted and n_cleared >= 1 and not mgr.retry_at, 'noted=%s cleared=%s' % (noted, n_cleared)) |
| check('N: retry_in يصل إلى payload اللوحة (الحقل موجود ولو صفرًا)', |
| all('retry_in' in ev for ev in (mgr.snapshot().get('events') or [{'retry_in': 0}])), str(vis_state)[:80]) |
| _BoomSender.last_exit_code = 0 |
| mgr.hammer.clear(); mgr.retry_at.clear() |
| mgr.journal.change(lambda d: d['events'].update({'gate:reset': {'username': 'hammeruser', 'room_id': '7'}})) |
| mgr._note_early_exit('hammeruser', _BoomSender(), lasted=40.0) |
| reset_ok = ('hammeruser' not in mgr.hammer and mgr._backoff('hammeruser') <= 60.0 |
| and 'gate:reset' not in mgr.retry_at) |
| mgr.journal.change(lambda d: d['events'].pop('gate:reset', None)) |
| |
| |
| floor_ok = third >= 20 and hammered > third |
| logged_ok = any('تأجيل إعادة الاتصال إلى %d ث' % int(third) in m for m in logs_tail) |
| check('N: عمليات متتالية قفلتها الوجهة خلال ثوانٍ ⇒ أرضية 20 ث ثم تصاعد موثّق في السجل', |
| floor_ok and logged_ok, 'third=%s fourth=%s logged=%s' % (third, hammered, logged_ok)) |
| check('N: جلسة طويلة ⇒ يُصفَّر عدّاد النقر وتعود الوتيرة الطبيعية', reset_ok, str(mgr.hammer)) |
|
|
| |
| class _HungrySender: |
| last_exit_code = 187 |
| last_source_gap = 25.0 |
|
|
|
|
| mgr.retry_min = 5.0 |
| mgr.hammer.clear(); mgr.retry_at.clear(); mgr.retry.clear() |
| logs_n2 = [] |
| mgr.log = lambda u, m: logs_n2.append(str(m)) |
| for _ in range(4): |
| mgr._note_early_exit('hungry', _BoomSender(), lasted=4.0) |
| penalized = mgr._backoff('hungry') > mgr.retry_min |
| mgr.hammer.clear(); mgr.retry_at.clear(); mgr.retry.clear() |
| logs_n2.clear() |
| for _ in range(4): |
| mgr._note_early_exit('hungry', _HungrySender(), lasted=4.0) |
| unpenalized = (mgr._backoff('hungry') == mgr.retry_min and not mgr.hammer.get('hungry') |
| and not mgr.retry_at and any('الجوع من جهة تيك توك' in m for m in logs_n2)) |
| check('N2: جوع المصدر يُلغي عقاب الوجهة (تأجيل باطل يطيل صمت المشاهدين)', |
| penalized and unpenalized, 'penalized=%s unpenalized=%s' % (penalized, unpenalized)) |
| |
| class _FeedingSender: |
| last_exit_code = 187 |
| last_source_gap = 0.2 |
|
|
|
|
| mgr.destinations['hammeruser'] = 'rtmps://old.example.invalid/live/OLDKEY' |
| seen_ensure = [] |
| mgr.ensure_stream = lambda u: (seen_ensure.append(u), mgr.destinations.__setitem__(u, 'rtmps://new.example.invalid/live/NEWKEY_FROM_API')) |
| mgr.hammer.clear() |
| for _ in range(3): |
| mgr._note_early_exit('hammeruser', _FeedingSender(), lasted=14.0) |
| |
| refreshed = (mgr.destinations.get('hammeruser', '').endswith('NEWKEY_FROM_API') and seen_ensure == ['hammeruser']) |
| check('N3: ثلاث إغلاقات مع مصدر يرسل تعيد قراءة عنوان الاستقبال فورًا (لا بعد موت الخيط)', |
| refreshed and any('جُدِّد عنوان الاستقبال' in m for m in logs_n2) |
| and mgr.destinations.get('hammeruser', '').endswith('NEWKEY_FROM_API'), |
| 'dest=%r logs=%s' % (mgr.destinations.get('hammeruser'), [m[:40] for m in logs_n2][-2:])) |
| mgr.retry_at.clear() |
| check('N3: sender_loop يقرأ الوجهة في كل دورة (النص SOURCE_OF_TRUTH هو dict العناوين)', |
| 'destination = self.destinations.get(user) or destination' in |
| __import__('inspect').getsource(ym.ManagedYouTube.sender_loop), '') |
| mgr.destinations.pop('hammeruser', None) |
| |
| mgr.journal.change(lambda dd: dd['events'].update({'rec:9': { |
| 'session_key': 'rec:9', 'username': 'recovered', 'nickname': 'r', 'room_id': '9', 'title': 't', |
| 'description': 'd', 'hashtags': '', 'privacy': 'public', 'marker': 'M', 'broadcast_id': 'BB', |
| 'bound': True, 'closing': False, 'phase': 'live', 'youtube_status': 'live', |
| 'created_at': time.time(), 'was_live': True, 'create_pending': False, 'last_poll': time.time(), |
| 'note': 'إعادة الاتصال مؤجّلة 68 ث (الوجهة أغلقت الاتصال ثلاث مرات والمصدر يرسل)'}})) |
| mgr.hammer['recovered'] = 5 |
| mgr.retry['recovered'] = 90.0 |
| mgr.retry_at['rec:9'] = time.monotonic() + 60 |
| logs_n4 = [] |
| mgr.log = lambda a, b: logs_n4.append(str(b)) |
| mgr._note_early_exit('recovered', _FeedingSender(), lasted=40.0) |
| _note_now = (mgr.journal.read()['events'].get('rec:9') or {}).get('note') or '' |
| |
| mgr.journal.change(lambda dd: dd['events'].update({'sta:8': { |
| 'session_key': 'sta:8', 'username': 'stableu', 'nickname': 's', 'room_id': '8', 'title': 't', |
| 'description': 'd', 'hashtags': '', 'privacy': 'public', 'marker': 'M2', 'broadcast_id': 'BS', |
| 'bound': True, 'closing': False, 'phase': 'live', 'youtube_status': 'live', |
| 'created_at': time.time(), 'was_live': True, 'create_pending': False, 'last_poll': time.time(), |
| 'note': 'إعادة الاتصال مؤجّلة 40 ث (الوجهة أغلقت الاتصال ثلاث مرات والمصدر يرسل)'}})) |
| mgr.destinations['stableu'] = 'rtmps://x.invalid/live/K' |
| mgr.hammer['stableu'] = 4 |
| mgr.retry['stableu'] = 80.0 |
| mgr.retry_at['sta:8'] = time.monotonic() + 40 |
| logs_n5 = [] |
| mgr.log = lambda a, b: logs_n5.append(str(b)) |
| n_cleared = mgr.mark_stream_stable('stableu') |
| _ev = mgr.journal.read()['events'].get('sta:8') or {} |
| check('N5: mark_stream_stable يُلغي النافذة والملاحظة والعدّاد ويُنزل الوتيرة للأصل', |
| n_cleared >= 3 and not mgr.retry_at and _ev.get('note', '') == '' and not mgr.hammer.get('stableu') |
| and mgr._backoff('stableu') == mgr.retry_min and any('مُسح تأجيل العقاب' in x for x in logs_n5), |
| 'cleared=%s note=%r' % (n_cleared, _ev.get('note', '')[:24])) |
| mgr.journal.change(lambda dd: dd['events'].pop('sta:8', None)) |
| mgr.journal.change(lambda dd: dd['events'].update({'ns:6': { |
| 'session_key': 'ns:6', 'username': 'notstarted', 'nickname': 'n', 'room_id': '6', 'title': 't', |
| 'description': 'd', 'hashtags': '', 'privacy': 'public', 'marker': 'M6', 'broadcast_id': 'BN', |
| 'bound': True, 'closing': False, 'phase': 'bound', 'youtube_status': 'ready', |
| 'created_at': time.time(), 'was_live': False, 'create_pending': False, 'last_poll': time.time(), |
| 'note': ''}})) |
| mgr.destinations['notstarted'] = 'rtmps://x.invalid/live/K6' |
| seen_ns = [] |
| mgr.ensure_stream = lambda u: seen_ns.append(u) |
| mgr.hammer.clear(); mgr.retry_at.clear(); mgr.retry.clear() |
| logs_n6 = [] |
| mgr.log = lambda a, b: logs_n6.append(str(b)) |
| for _ in range(3): |
| mgr._note_early_exit('notstarted', _FeedingSender(), lasted=12.0) |
| _ev6 = mgr.journal.read()['events'].get('ns:6') or {} |
| check('N6: حدث بحالة ready — لا يُعاد قراءة المفتاح (كان قراءة API بلا معنى على سبب معروف)', |
| not seen_ns, 'ensure_stream=%s' % seen_ns) |
| check('N6: السبب يصل اللوحة والسجل ببادئة تُمسح عند أول تدفق مقبول', |
| str(_ev6.get('note') or '').startswith('إعادة الاتصال مؤجّلة') and 'لم يُشغَّل' in str(_ev6.get('note')) |
| and any('لم يبدأ بعد' in x for x in logs_n6) and any('السبب المعلوم' in x for x in logs_n6), |
| 'note=%r' % str(_ev6.get('note'))[:60]) |
| |
| mgr.journal.change(lambda dd: dd['events'].update({'ns:6': dict(dd['events']['ns:6'], |
| was_live=True, youtube_status='active')})) |
| mgr.hammer.clear(); mgr.retry_at.clear(); mgr.retry.clear() |
| seen_live = [] |
| mgr.ensure_stream = lambda u: seen_live.append(u) |
| for _ in range(3): |
| mgr._note_early_exit('notstarted', _FeedingSender(), lasted=12.0) |
| check('N6: بثّ كان حيًا — مسار تجديد المفتاح يعمل كما كان', seen_live == ['notstarted'], 'seen=%s' % seen_live) |
| mgr.journal.change(lambda dd: dd['events'].pop('ns:6', None)) |
| mgr.hammer.clear(); mgr.retry_at.clear(); mgr.retry.clear() |
| import app as _app |
| _m1 = _app.throttle_failure('sp', 'تيك توك رفض الجلسة (403)', now=1000) |
| _m2 = _app.throttle_failure('sp', 'تيك توك رفض الجلسة (403)', now=1015) |
| _m3 = _app.throttle_failure('sp', 'تيك توك رفض الجلسة (403)', now=1300) |
| _m4 = _app.throttle_failure('sp', 'سبب آخر مختلف', now=1301) |
| _o1 = _app.throttle_failure('آخر', 'تيك توك رفض الجلسة (403)', now=1301) |
| check('N7: التطابق داخل دقيقتين يُكتم (لا سطر)، وغير المطابق يُكتب فورًا', |
| _m1 and _m2 is None and _m3 and _m4, 'm1=%r m2=%r m3=%r m4=%r' % (_m1, _m2, _m3, _m4)) |
| check('N7: عند أول كتابة بعد الكتم يُلحق عدد ما كُتم، وحساب آخر لا يتأثر', |
| 'كُتمت 1' in str(_m3) and 'كُتمت' not in str(_m4) and str(_o1) == 'تيك توك رفض الجلسة (403)', |
| 'm3=%r m4=%r o1=%r' % (_m3, _m4, _o1)) |
| _src7 = (DIR / 'app.py').read_text(encoding='utf-8') |
| check('N7: worker يستعمل الكتم والحالة تبقى صادقة (التحديث خارج الكتم)', |
| 'out=throttle_failure(user,msg)' in _src7 |
| and "_set_state(user,'ERROR' if 'رفض' in msg else 'BACKOFF'" in _src7, |
| 'الاستدعاء أو تحديث الحالة مفقود') |
| _app._failure_notes.clear() |
| mgr.journal.change(lambda dd: dd['events'].update({'ex:9': { |
| 'session_key': 'ex:9', 'username': 'expwin', 'nickname': 'e', 'room_id': '9', 'title': 't', |
| 'description': 'd', 'hashtags': '', 'privacy': 'public', 'marker': 'M9', 'broadcast_id': 'BE', |
| 'bound': True, 'closing': False, 'phase': 'live', 'youtube_status': 'active', |
| 'created_at': time.time(), 'was_live': True, 'create_pending': False, 'last_poll': time.time(), |
| 'note': 'إعادة الاتصال مؤجّلة 17 ث (الوجهة أغلقت الاتصال ثلاث مرات والمصدر يرسل)'}})) |
| mgr.retry_at['ex:9'] = time.monotonic() - 1.0 |
| mgr._gate_note_at['ex:9'] = time.monotonic() - 30.0 |
| mgr.senders.pop('ex:9', None) |
| mgr.destinations.pop('expwin', None) |
| mgr.ensure_stream = lambda u: (_ for _ in ()).throw(RuntimeError('لا عنوان في الاختبار')) |
| logs8 = [] |
| mgr.log = lambda a2, b: logs8.append(str(b)) |
| try: |
| mgr.start_sender('ex:9') |
| except Exception: |
| pass |
| _ev9 = mgr.journal.read()['events'].get('ex:9') or {} |
| check('N8: نافذة منتهية — القفل والملاحظة المجمدة يُمسحان ولا يعيقان المسار', |
| 'ex:9' not in mgr.retry_at and not str(_ev9.get('note') or ''), 'note=%r q=%s' |
| % (str(_ev9.get('note'))[:40], 'ex:9' in mgr.retry_at)) |
| check('N8: المسح يُعلَن في السجل مرة واحدة', sum('انتهت نافذة التأجيل' in x for x in logs8) == 1, |
| 'logs=%r' % [x[:60] for x in logs8]) |
| |
| mgr.retry_at['ex:9'] = time.monotonic() + 60.0 |
| mgr._gate_note_at.pop('ex:9', None) |
| try: |
| mgr.start_sender('ex:9') |
| except Exception: |
| pass |
| _ev9b = mgr.journal.read()['events'].get('ex:9') or {} |
| check('N8: نافذة حيّة — الملاحظة تُكتب والقفل يبقى', |
| str(_ev9b.get('note') or '').startswith('إعادة الاتصال مؤجّلة') and 'ex:9' in mgr.retry_at, |
| 'note=%r' % str(_ev9b.get('note'))[:50]) |
| mgr.journal.change(lambda dd: dd['events'].pop('ex:9', None)) |
| mgr.retry_at.pop('ex:9', None) |
| mgr._gate_note_at.pop('ex:9', None) |
| |
| _jb9 = json.loads(json.dumps(mgr.journal.read())) |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, history=[])) |
| mgr.max_events = 3 |
| calls = {'n': 0} |
| def _obs(u): |
| calls['n'] += 1 |
| raise RuntimeError('تيك توك رفض الجلسة (403) — توكن sessionid منتهٍ') |
| mgr._observe = _obs |
| notes9 = [] |
| mgr.log = lambda a2, b: notes9.append(str(b)) |
| mgr.accounts = lambda: ['pa'] |
| mgr.auth_pause.clear() |
| mgr.tick() |
| first = calls['n'] |
| mgr.tick() |
| check('N9: رفض 403 يضبط إيقاف الرصد للحساب المرفوض وحده، والدورة التالية لا تسأل تيك توك', |
| first == 1 and calls['n'] == 1 and mgr.auth_pause.get('pa', 0) > time.monotonic(), |
| 'calls=%s pause=%s' % (calls['n'], 'yes' if mgr.auth_pause.get('pa', 0) > time.monotonic() else 'no')) |
| mgr.auth_pause['pa'] = time.monotonic() - 1.0 |
| mgr.tick() |
| check('N9: إيقاف منتهٍ يعيد السؤال (لا جمود دائم)', calls['n'] == 2, 'calls=%s' % calls['n']) |
| mgr.auth_pause['pa'] = time.monotonic() - 1.0 |
| def _obs5(u): |
| calls['n'] += 1 |
| raise RuntimeError('تيك توك أعاد 500؛ سيُعاد المحاولة لاحقًا') |
| mgr._observe = _obs5 |
| mgr.tick() |
| check('N9: خطأ غير هوية لا يضبط الإيقاف (ويُنهي ما ضُبط سابقًا) — الرصد يبقى بكامل سرعته', |
| calls['n'] == 3 and not mgr.auth_pause.get('pa'), 'calls=%s pause=%s' |
| % (calls['n'], mgr.auth_pause.get('pa'))) |
| def _obsok(u): |
| calls['n'] += 1 |
| return {'status': 'offline', 'room_id': 'x'} |
| mgr._observe = _obsok |
| mgr.tick() |
| check('N9: نجاح الرصد يمسح الإيقاف', calls['n'] == 4 and not mgr.auth_pause.get('pa'), 'calls=%s' % calls['n']) |
| def _restore9(dd): |
| dd.clear(); dd.update(_jb9) |
| mgr.journal.change(_restore9) |
| mgr.auth_pause.clear() |
| |
| _obs10 = {'sources': [ |
| {'url': 'https://x/flv-a', 'media': 'flv', 'codec': 'h264', 'label': 'hd · h264'}, |
| {'url': 'https://x/pl.m3u8', 'media': 'hls', 'codec': 'h264', 'label': 'hd · h264 · HLS'}]} |
| mgr.starve.pop('u10', None) |
| base10 = mgr._select_source('u10', _obs10) |
| check('N10: بلا جوع — FLV أولًا كما هي', base10[0]['media'] == 'flv', base10[0]['media']) |
| mgr.starve['u10'] = 2 |
| rot10 = mgr._select_source('u10', _obs10) |
| check('N10: جوعان ⇒ أول مرشح غير FLV يُقدَّم أولًا (اختبار النقل البديل)', |
| rot10[0]['media'] == 'hls' and rot10[-1]['media'] == 'flv', |
| [c['media'] for c in rot10]) |
| _sd10 = _FeedingSender(); _sd10.last_source_gap = 12.0 |
| mgr.log = lambda a2, b: None |
| mgr._note_early_exit('u10', _sd10, lasted=12.0) |
| check('N10: خروج جوع يزيد عدّاد التناوب', int(mgr.starve.get('u10') or 0) >= 3, |
| 'starve=%s' % mgr.starve.get('u10')) |
| mgr.mark_stream_stable('u10') |
| check('N10: 25 ث مُسلَّمة تُلغي التناوب فيعود FLV أولًا', |
| not mgr.starve.get('u10') and mgr._select_source('u10', _obs10)[0]['media'] == 'flv', |
| 'starve=%s' % mgr.starve.get('u10')) |
| mgr.starve.pop('u10', None) |
| logs11 = [] |
| mgr.log = lambda a2, b: logs11.append(str(b)) |
| mgr._hold_notes.pop('hz', None) |
| mgr._log_throttled('hz', 'نتمسك بآخر مصدر صالح (100s)') |
| mgr._log_throttled('hz', 'نتمسك بآخر مصدر صالح (133s)') |
| check('N11: الرسالة المتطابقة داخل النافذة تُكتم (سطر واحد فقط)', len(logs11) == 1, 'logs=%d' % len(logs11)) |
| _mh = mgr._hold_notes.get('hz') |
| _mh[1] -= 121.0 |
| mgr._log_throttled('hz', 'نتمسك بآخر مصدر صالح (254s)') |
| check('N11: بعد انتهاء النافذة تُكتب وتُلحق عدد ما كُتم', |
| len(logs11) == 2 and 'كُتمت 1' in logs11[-1], 'last=%r' % logs11[-1][:60]) |
| mgr._log_throttled('hz', 'رسالة أخرى مختلفة') |
| check('N11: رسالة غير متطابقة تُكتب فورًا', len(logs11) == 3, 'logs=%d' % len(logs11)) |
| mgr._hold_notes.pop('hz', None) |
| import threading as _th |
| mgr.journal.change(lambda dd: dd['events'].update({'bl:1': { |
| 'session_key': 'bl:1', 'username': 'blocked', 'nickname': 'b', 'room_id': '5', 'title': 't', |
| 'description': 'd', 'hashtags': '', 'privacy': 'public', 'marker': 'MB', 'broadcast_id': 'BB', |
| 'bound': True, 'closing': False, 'phase': 'live', 'youtube_status': 'active', |
| 'created_at': time.time(), 'was_live': True, 'create_pending': False, 'last_poll': time.time(), |
| 'note': 'يوتيوب يستقبل؛ طُلب بدء الحدث للعامة حسب الخصوصية'}})) |
| mgr._observe = lambda u, **kw: {'status': 'unknown', 'room_id': '', 'sources': [], 'nickname': 'b', 'live_title': 't'} |
| _stop12 = _th.Event() |
| _sd12 = _FeedingSender() |
| _th12 = _th.Thread(target=mgr.sender_loop, args=('bl:1', 'blocked', '5', 'rtmps://x/k', _stop12, _sd12), daemon=True) |
| _th12.start(); time.sleep(2) |
| _ev12 = mgr.journal.read()['events'].get('bl:1') or {} |
| check('N12: حجب المصادر — الحدث محفوظ والمشرف يبقى للمحاولة بدل وميض جلسات جديدة', |
| _th12.is_alive() is True |
| and str(_ev12.get('note') or '') == 'تيك توك لا يرجع مصادر لهذا الخادم الآن؛ الحدث محفوظ والمحاولة كل دورة رصد', |
| 'alive=%s note=%r' % (_th12.is_alive(), str(_ev12.get('note'))[:50])) |
| _stop12.set();_th12.join(timeout=4) |
| mgr.journal.change(lambda dd: dd['events'].pop('bl:1', None)) |
| st13 = [] |
| mgr.max_events = 9 |
| _pre13 = mgr.journal.read().get('enabled') |
| mgr.journal.change(lambda dd: dd.update(enabled=True)) |
| mgr.log = lambda a2, b: st13.append(str(b)) |
| mgr.last_seen_status.pop('pa', None) |
| mgr._observe = lambda u: {'status': 'offline', 'room_id': '', 'sources': [], 'nickname': 'x', 'live_title': 't'} |
| mgr.tick() |
| n13a = sum('غير مباشر الآن' in x for x in st13) |
| mgr.tick() |
| n13b = sum('غير مباشر الآن' in x for x in st13) |
| check('N13: أول تقرير غير-حيّ يُكتب مرة', n13a == 1, 'n=%d' % n13a) |
| check('N13: تكرار نفس الحالة لا يعيد السطر', n13b == 1, 'n=%d' % n13b) |
| mgr._observe = lambda u: {'status': 'live', 'room_id': '13', 'sources': [], 'nickname': 'x', 'live_title': 't'} |
| mgr.tick() |
| mgr._observe = lambda u: {'status': 'offline', 'room_id': '', 'sources': [], 'nickname': 'x', 'live_title': 't'} |
| mgr.tick() |
| n13c = sum('غير مباشر الآن' in x for x in st13) |
| check('N13: streak جديد (عاد حيًّا ثم انطفأ) يُكتب من جديد', n13c == 2, 'n=%d' % n13c) |
| mgr.last_seen_status.pop('pa', None) |
| mgr.max_events = 3 |
| mgr.journal.change(lambda dd: dd.update(enabled=_pre13)) |
| |
| _jb14 = json.loads(json.dumps(mgr.journal.read())) |
| _pre14_acc = mgr.accounts |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, history=[])) |
| mgr.max_events = 3 |
| mgr.accounts = lambda: ['m1', 'm2'] |
| mgr.last_seen_status.pop('m1', None); mgr.last_seen_status.pop('m2', None) |
| def _obs14(u): |
| return {'status': 'live', 'room_id': 'R1' if u == 'm1' else 'R2', |
| 'sources': [{'url': 'https://x/%s.flv' % u, 'media': 'flv', 'codec': 'h264', |
| 'label': 'hd · h264'}], |
| 'nickname': u, 'live_title': 't'} |
| mgr._observe = _obs14 |
| seen14, opened14, driven14 = [], [], [] |
| mgr.ensure_stream = lambda u: seen14.append(u) |
| def _open14(u, o): |
| opened14.append((u, o.get('room_id'))) |
| key = u + ':' + o['room_id'] |
| mgr.journal.change(lambda dd: dd['events'].update({key: { |
| 'session_key': key, 'username': u, 'nickname': u, 'room_id': o['room_id'], |
| 'title': 't', 'description': 'd', 'hashtags': '', 'privacy': 'public', |
| 'marker': 'M', 'broadcast_id': 'B-' + u, 'bound': True, 'closing': False, |
| 'phase': 'live', 'youtube_status': 'active', 'created_at': time.time(), |
| 'was_live': True, 'create_pending': False, 'last_poll': time.time(), 'note': ''}})) |
| return True |
| mgr.open_event = _open14 |
| mgr.drive_event = lambda key: driven14.append(key) |
| mgr.tick() |
| _keys14 = set(mgr.journal.read()['events'].keys()) |
| check('N14: مذيعان حيّان في دورة واحدة ⇒ حدثان متزامنان بلا تلوّث مفاتيح', |
| _keys14 == {'m1:R1', 'm2:R2'}, 'keys=%s' % sorted(_keys14)) |
| check('N14: ensure_stream/open_event لكل حساب باسمه (لا تبادل أدوار)', |
| seen14 == ['m1', 'm2'] and opened14 == [('m1', 'R1'), ('m2', 'R2')] |
| and driven14 == ['m1:R1', 'm2:R2'], |
| 'seen=%s opened=%s driven=%s' % (seen14, opened14, driven14)) |
| |
| mgr.journal.change(lambda dd: dd.update(events={}, history={}.copy() or dd.get('history', []))) |
| mgr.journal.change(lambda dd: dd.update(history=[])) |
| mgr.max_events = 1 |
| mgr.accounts = lambda: ['m1', 'm2'] |
| mgr.tick() |
| check('N14: السقف max_events=1 يُلتزم (المذيع الثاني ينتظر ولا يُخترق)', |
| set(mgr.journal.read()['events'].keys()) == {'m1:R1'} and 'الحد الأقصى' in mgr.status_text, |
| 'keys=%s status=%r' % (sorted(mgr.journal.read()['events'].keys()), mgr.status_text[:40])) |
| def _restore14(dd): |
| dd.clear(); dd.update(_jb14) |
| mgr.journal.change(_restore14) |
| mgr.accounts = _pre14_acc |
| mgr.max_events = 3 |
| |
| _jb15 = json.loads(json.dumps(mgr.journal.read())) |
| _orig_remote15, _orig_api15, _orig_log15, _orig_stop15 = mgr.remote, mgr.api, mgr.log, mgr.stop_sender |
| def _mk15(status): |
| mgr.journal.change(lambda dd: dd['events'].update({'mm:1': { |
| 'session_key': 'mm:1', 'username': 'mm1', 'nickname': 'm', 'room_id': '8', 'title': 't', |
| 'description': 'd', 'hashtags': '', 'privacy': 'public', 'marker': 'MK-EVENT-x', |
| 'broadcast_id': 'BB15', 'bound': True, 'closing': True, 'phase': 'closing', |
| 'youtube_status': 'active', 'created_at': time.time(), 'was_live': True, |
| 'create_pending': False, 'last_poll': time.time(), 'note': ''}})) |
| calls15 = [] |
| class _API15: |
| def call(self, *a, **k): calls15.append(a) |
| mgr.api = _API15() |
| mgr.remote = lambda res, rid: {'id': rid, 'snippet': {'description': 'وصف بلا علامة'}, |
| 'status': {'lifeCycleStatus': status}} |
| logs15 = [] |
| mgr.log = lambda a2, b: logs15.append(str(b)) |
| return calls15, logs15 |
| calls15, logs15 = _mk15('live') |
| ok15 = mgr.finish_event('mm:1') |
| _h15 = mgr.journal.read().get('history') or [] |
| check('N15: علامة مفقودة وكان البث فعليًا ⇒ transition complete + أرشفة (لا عالق في closing)', |
| ok15 and 'mm:1' not in mgr.journal.read()['events'] |
| and any('complete' in str(a) for a in calls15) |
| and _h15 and _h15[-1].get('outcome') == 'completed_marker_lost' |
| and any('WARN' in x for x in logs15), |
| 'ok=%s calls=%s outcome=%s' % (ok15, calls15, _h15[-1].get('outcome') if _h15 else '—')) |
| calls15b, _ = _mk15('ready') |
| ok15b = mgr.finish_event('mm:1') |
| _h15b = mgr.journal.read().get('history') or [] |
| check('N15: علامة مفقودة وغير مبدوء ⇒ أرشفة محلية فقط (لا حذف ولا إنهاء لبث قد يكون للغير)', |
| ok15b and not calls15b and _h15b and str(_h15b[-1].get('outcome')).startswith('marker_mismatch'), |
| 'ok=%s calls=%s outcome=%s' % (ok15b, calls15b, _h15b[-1].get('outcome') if _h15b else '—')) |
| def _restore15(dd): |
| dd.clear(); dd.update(_jb15) |
| mgr.journal.change(_restore15) |
| mgr.remote, mgr.api, mgr.log, mgr.stop_sender = _orig_remote15, _orig_api15, _orig_log15, _orig_stop15 |
| |
| _jb16 = json.loads(json.dumps(mgr.journal.read())) |
| _pre16_acc, _pre16_me = mgr.accounts, mgr._observe |
| _pre16_es, _pre16_oe, _pre16_api = mgr.ensure_stream, mgr.open_event, mgr.api |
| _pre16_log, _pre16_fin = mgr.log, mgr.finish_event |
| _pre16_arch = mgr.archive_event |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, history=[])) |
| mgr.max_events = 3 |
| mgr.accounts = lambda: ['rj1'] |
| def _obs16(u, *a, **k): |
| return {'status': 'live', 'room_id': 'R9', |
| 'sources': [{'url': 'https://x/rj.flv', 'media': 'flv', 'codec': 'h264', 'label': 'hd'}], |
| 'nickname': u, 'live_title': 't'} |
| mgr._observe = _obs16 |
| mgr.ensure_stream = lambda u: None |
| class _APIErr(Exception): |
| pass |
| from youtube_api import APIError as _APIErrCls |
| def _open16(u, o): |
| mgr._last_obs = {'username': u, 'room_id': o.get('room_id')} |
| raise _APIErrCls(403, 'livePermissionBlocked') |
| mgr.open_event = _open16 |
| logs16 = [] |
| mgr.log = lambda a2, b: logs16.append(str(b)) |
| mgr.last_seen_status.pop('rj1', None) |
| mgr.auth_pause.pop('rj1', None) |
| mgr.tick() |
| check('N16: رفض 403 عند الفتح ⇒ السجل يسمّي الصلاحية والحدث يُغلق بنظام (لا planned معلّقة)', |
| any('403/livePermissionBlocked' in str(x) for x in logs16) |
| and all(str(e.get('note') or '').find('صلاحية') < 0 for e in mgr.journal.read().get('events', {}).values()), |
| 'logs=%s events=%s' % ([str(x)[:60] for x in logs16], list(mgr.journal.read().get('events', {}).keys()))) |
| def _restore16(dd): |
| dd.clear(); dd.update(_jb16) |
| mgr.journal.change(_restore16) |
| mgr.accounts, mgr._observe = _pre16_acc, _pre16_me |
| mgr.ensure_stream, mgr.open_event, mgr.api = _pre16_es, _pre16_oe, _pre16_api |
| mgr.log, mgr.finish_event, mgr.archive_event = _pre16_log, _pre16_fin, _pre16_arch |
| |
| _jb16b = json.loads(json.dumps(mgr.journal.read())) |
| _pre16b_es, _pre16b_log, _pre16b_probe = mgr.ensure_stream, mgr.log, mgr.probe |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, history=[])) |
| mgr.max_events = 3 |
| mgr.accounts = lambda: ['rj1'] |
| mgr._observe = _obs16 |
| mgr.probe = lambda u, c: {'video': 'h264', 'audio': 'aac'} |
| |
| _pre16b_oe, _pre16b_sn = mgr.open_event, mgr._skip_note |
| mgr.open_event = ym.ManagedYouTube.open_event.__get__(mgr) |
| mgr._skip_note = ym.ManagedYouTube._skip_note.__get__(mgr) |
| _es16b_calls = {'n': 0} |
| def _es16b(u): |
| |
| |
| |
| _es16b_calls['n'] += 1 |
| if _es16b_calls['n'] == 1: |
| raise _APIErrCls(403, 'livePermissionBlocked') |
| return None |
| mgr.ensure_stream = _es16b |
| logs16b = [] |
| mgr.log = lambda a2, b: logs16b.append(str(b)) |
| mgr.last_seen_status.pop('rj1', None) |
| mgr.auth_pause.pop('rj1', None) |
| mgr._blocked403.pop('rj1:R9', None) |
| mgr.tick() |
| _events16b_after1 = len(mgr.journal.read().get('events') or {}) |
| mgr.tick() |
| _rejects16b = sum(1 for x in logs16b if '403/livePermissionBlocked' in str(x)) |
| check('N16b: بعد رفض 403 يُقفل المفتاح (rj1:R9) — open_event الحقيقي يرفض إعادة الفتح بملاحظة انتظار، بلا planned ولا رفض متكرر', |
| 'rj1:R9' in mgr._blocked403 |
| and _events16b_after1 == 0 |
| and _rejects16b == 1 |
| and any('يوتيوب رفض إنشاء حدث لهذه الجلسة' in str(v) for v in (mgr._skip_last or {}).values()), |
| 'blocked=%s events=%d rejects=%d skip=%s' % (list(mgr._blocked403.keys()), _events16b_after1, |
| _rejects16b, |
| [str(v)[:42] for v in (mgr._skip_last or {}).values()])) |
| mgr.ensure_stream = _pre16b_es |
| mgr.log = _pre16b_log |
| mgr.probe = _pre16b_probe |
| mgr.open_event, mgr._skip_note = _pre16b_oe, _pre16b_sn |
| def _restore16b(dd): |
| dd.clear(); dd.update(_jb16b) |
| mgr.journal.change(_restore16b) |
| mgr._blocked403.pop('rj1:R9', None) |
|
|
| |
| |
| |
| _jb16c = json.loads(json.dumps(mgr.journal.read())) |
| _pre16c_api, _pre16c_log = mgr.api, mgr.log |
| _pre16c_es, _pre16c_oe, _pre16c_probe = mgr.ensure_stream, mgr.open_event, mgr.probe |
| mgr.journal.change(_restore16b) |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, history=[])) |
| mgr.max_events = 3 |
| mgr.accounts = lambda: ['rj1'] |
| def _obs16c(u, *a, **k): |
| return {'status': 'live', 'room_id': 'R7', |
| 'sources': [{'url': 'https://x/rj.flv', 'media': 'flv', 'codec': 'h264', 'label': 'hd'}], |
| 'nickname': u, 'live_title': 't'} |
| mgr._observe = _obs16c |
| mgr.ensure_stream = lambda u: None |
| mgr.probe = lambda u, c: {'video': 'h264', 'audio': 'aac'} |
| _pre16c_oe2, _pre16c_de = mgr.open_event, mgr.drive_event |
| _pre16c_fe, _pre16c_ae = mgr.finish_event, mgr.archive_event |
| mgr.open_event = ym.ManagedYouTube.open_event.__get__(mgr) |
| mgr.drive_event = ym.ManagedYouTube.drive_event.__get__(mgr) |
| mgr.finish_event = ym.ManagedYouTube.finish_event.__get__(mgr) |
| mgr.archive_event = ym.ManagedYouTube.archive_event.__get__(mgr) |
| def _api16c_call(*a, **k): |
| raise _APIErrCls(403, 'livePermissionBlocked') |
| mgr.api = type('FakeAPI403', (), {'call': staticmethod(_api16c_call)})() |
| logs16c = [] |
| mgr.log = lambda a2, b: logs16c.append(str(b)) |
| mgr.last_seen_status.pop('rj1', None) |
| mgr.auth_pause.pop('rj1', None) |
| mgr._blocked403.pop('rj1:R7', None) |
| mgr.tick() |
| _ev16c = (mgr.journal.read().get('events') or {}).get('rj1:R7') |
| _hist16c = mgr.journal.read().get('history') or [] |
| _rejects16c = sum(1 for x in logs16c if '403/livePermissionBlocked' in str(x)) |
| _note16c = next((str(h.get('note') or '') for h in _hist16c if h.get('session_key') == 'rj1:R7'), '') |
| check('N16c: رفض 403 في drive_event (POST الحدث) ⇒ إغلاق بنظام بملاحظة صادقة + قفل المفتاح — لا planned تعيد POST كل دورة', |
| _ev16c is None |
| and any(h.get('session_key') == 'rj1:R7' and h.get('outcome') == 'cancelled_before_create' for h in _hist16c) |
| and 'صلاحية' in _note16c |
| and 'rj1:R7' in mgr._blocked403 |
| and _rejects16c == 1, |
| 'in_events=%s hist=%s note=%r blocked=%s rejects=%d' % ( |
| _ev16c is not None, |
| [(h.get('session_key'), h.get('outcome')) for h in _hist16c], |
| _note16c[:60], list(mgr._blocked403.keys()), _rejects16c)) |
| mgr.api, mgr.log = _pre16c_api, _pre16c_log |
| mgr.ensure_stream, mgr.open_event, mgr.probe = _pre16c_es, _pre16c_oe, _pre16c_probe |
| mgr.drive_event, mgr.finish_event, mgr.archive_event = _pre16c_de, _pre16c_fe, _pre16c_ae |
| def _restore16c(dd): |
| dd.clear(); dd.update(_jb16c) |
| mgr.journal.change(_restore16c) |
| mgr._blocked403.pop('rj1:R7', None) |
|
|
| |
| |
| |
| |
| _ms17 = getattr(mgr, 'manager_stop', None) |
| if _ms17 is not None: |
| _ms17.set() |
| _mt17 = getattr(mgr, 'manager_thread', None) |
| if _mt17 is not None and _mt17.is_alive():_mt17.join(timeout=5) |
| _jb17 = json.loads(json.dumps(mgr.journal.read())) |
| _pre17_api, _pre17_log, _pre17_stop = mgr.api, mgr.log, mgr.stop_sender |
| def _restore17(dd): |
| dd.clear(); dd.update(_jb17) |
| mgr.journal.change(_restore17) |
| mgr.journal.change(lambda dd: dd.update(enabled=False, channel={'id': 'OLDCH', 'title': 'القناة القديمة'}, |
| streams={'rj1': {'id': 'oldstream'}}, events={ |
| 'rj1:R5': {'session_key': 'rj1:R5', 'name': 'rj1', 'title': 't', 'description': 'm17', 'privacy': 'unlisted', |
| 'date': 'd', 'time': 't', 'username': 'rj1', 'room_id': 'R5', 'broadcast_id': None, |
| 'create_pending': False, 'phase': 'planned', 'bound': False, 'was_live': False, 'closing': False, |
| 'last_poll': 0, 'offline_since': None, 'offline_count': 0, 'note': ''}}, history=[])) |
| _stop17 = [] |
| mgr.stop_sender = lambda k: _stop17.append(k) or True |
| logs17 = [] |
| mgr.log = lambda a2, b: logs17.append(str(b)) |
| class _ChAPI: |
| def __init__(self, cid): |
| self.cid = cid |
| def call(self, resource, method='GET', params=None, body=None): |
| if resource == 'channels': |
| return {'items': [{'id': self.cid, 'snippet': {'title': 'قناة جديدة'}}]} |
| raise AssertionError('نداء غير متوقع ' + resource) |
| mgr.api = _ChAPI('NEWCH') |
| _safe17 = False |
| try: |
| mgr.check_channel() |
| except RuntimeError as e: |
| _safe17 = 'القناة المفوضة تغيرت' in str(e) |
| check('N17a: تغيّر القناة بلا تأكيد يبقى توقفًا آمنًا — لا هجرة صامتة لأحداث لا تخص القناة', _safe17, 'safe=%r' % _safe17) |
| _rep17 = mgr.check_channel(report_only=True) |
| _d17b = mgr.journal.read() |
| check('N17c: فحص الربط يبلّغ عن القناة الجديدة دون اعتمادها — التوقف الآمن وسجل القناة وأحداثها كما هي', |
| _rep17.get('id') == 'NEWCH' and (_rep17.get('previous') or {}).get('id') == 'OLDCH' |
| and (_d17b.get('channel') or {}).get('id') == 'OLDCH' |
| and any(e.get('username') == 'rj1' for e in (_d17b.get('events') or {}).values()) |
| and (_d17b.get('streams') or {}).get('rj1', {}).get('id') == 'oldstream', |
| 'rep=%r channel=%s events=%d streams=%s' % (_rep17, (_d17b.get('channel') or {}).get('id'), |
| len(_d17b.get('events') or {}), list((_d17b.get('streams') or {}).keys()))) |
| _ch17 = mgr.check_channel(allow_switch=True, expected='NEWCH') |
| _d17 = mgr.journal.read() |
| _h17 = [h for h in (_d17.get('history') or []) if h.get('outcome') == 'local_cancelled_channel_switch'] |
| check('N17b: التبديل المتعمد يؤرشف أحداث القناة السابقة محليًا ويُسجّد مصادرها ويعتمد الجديدة بسجل صادق', |
| _ch17.get('id') == 'NEWCH' and not _d17.get('events') and not _d17.get('streams') |
| and len(_h17) == 1 and _h17[0].get('session_key') == 'rj1:R5' |
| and 'القناة السابقة' in str(_h17[0].get('note') or '') |
| and (_d17.get('channel') or {}).get('id') == 'NEWCH' |
| and any('تم اعتماد قناة جديدة' in x for x in logs17), |
| 'ch=%r events=%s streams=%s hist=%s stop=%s' % (_ch17, list((_d17.get('events') or {}).keys()), |
| list((_d17.get('streams') or {}).keys()), |
| [(h.get('session_key'), h.get('outcome')) for h in (_d17.get('history') or [])], _stop17)) |
| mgr.api, mgr.log, mgr.stop_sender = _pre17_api, _pre17_log, _pre17_stop |
| mgr.journal.change(_restore17) |
|
|
| |
| |
| _jb18 = json.loads(json.dumps(mgr.journal.read())) |
| _pre18_api, _pre18_log, _pre18_es, _pre18_ob, _pre18_probe = mgr.api, mgr.log, mgr.ensure_stream, mgr._observe, mgr.probe |
| def _restore18(dd): |
| dd.clear(); dd.update(_jb18) |
| _posts18 = [] |
| class _FakeAPI18: |
| def call(self, resource, method='GET', params=None, body=None): |
| if resource == 'liveBroadcasts' and method == 'POST': |
| _posts18.append(body) |
| return {'id': 'bb18'} |
| return {'items': []} |
| def _obs18(u, *a, **k): |
| return {'status': 'live', 'room_id': 'R1x', |
| 'sources': [{'url': 'https://x/rj.flv', 'media': 'flv', 'codec': 'h264', 'label': 'hd'}], |
| 'nickname': u, 'live_title': 't'} |
| _au18 = mgr._adult_account('AHMEDBARBOOKA1') and not mgr._adult_account('muhajer_iraqi') |
| mgr.journal.change(_restore18) |
| mgr.api = _FakeAPI18() |
| mgr._observe = _obs18 |
| mgr.ensure_stream = lambda u: None |
| mgr.probe = lambda u, c: {'video': 'h264', 'audio': 'aac'} |
| |
| mgr.open_event = ym.ManagedYouTube.open_event.__get__(mgr) |
| mgr.drive_event = ym.ManagedYouTube.drive_event.__get__(mgr) |
| logs18 = [] |
| mgr.log = lambda a2, b: logs18.append(str(b)) |
| mgr.last_seen_status.pop('ahmedbarbooka1', None); mgr.auth_pause.pop('ahmedbarbooka1', None) |
| mgr._blocked403.pop('ahmedbooka1:R1x', None); mgr._blocked403.pop('ahmedbarbooka1:R1x', None) |
| mgr.accounts = lambda: ['ahmedbarbooka1'] |
| mgr.max_events = 3 |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, history=[])) |
| mgr.tick() |
| _post_adult = [b for b in _posts18 if isinstance(b, dict)] |
| _ok18 = bool(_post_adult) and any( |
| (b.get('status') or {}).get('selfDeclaredMadeForKids') is False for b in _post_adult) |
| mgr.journal.change(lambda dd: dd.update(events={}, history=[])) |
| mgr.accounts = lambda: ['rj1'] |
| mgr.last_seen_status.pop('rj1', None); mgr.auth_pause.pop('rj1', None) |
| mgr._blocked403.pop('rj1:R1x', None) |
| mgr.tick() |
| _ok18b = any((b.get('status') or {}).get('selfDeclaredMadeForKids') is None for b in _posts18[len(_post_adult):]) |
| check('N18: حسابات المذيع المخصص تُنشأ بإعلان selfDeclaredMadeForKids=false — والحسابات العادية بلا إعلان', |
| _au18 and _ok18 and _ok18b, |
| 'adult_helper=%r adult_post=%s normal_post=%s' % (_au18, |
| [(b.get('status') or {}) for b in _post_adult], [b.get('status') for b in _posts18[len(_post_adult):]])) |
| mgr.api, mgr.log, mgr.ensure_stream = _pre18_api, _pre18_log, _pre18_es |
| mgr._observe, mgr.probe = _pre18_ob, _pre18_probe |
| mgr.journal.change(_restore18) |
|
|
| |
| |
| _jb23 = json.loads(json.dumps(mgr.journal.read())) |
| _pre23_api, _pre23_log, _pre23_stop = mgr.api, mgr.log, mgr.stop_sender |
| def _restore23(dd): |
| dd.clear(); dd.update(_jb23) |
| _deleted23 = [] |
| class _DelAPI23: |
| def call(self, resource, method='GET', params=None, body=None): |
| if resource == 'liveBroadcasts' and method == 'DELETE': |
| _deleted23.append(params.get('id')) |
| return {} |
| if resource == 'liveBroadcasts' and method == 'GET': |
| return {'items': [{'id': 'bb23', 'status': {'lifeCycleStatus': 'liveStarting'}, |
| 'snippet': {'description': 'desc\nMARK23'}}]} |
| return {'items': []} |
| mgr.journal.change(_restore23) |
| mgr.stop_sender = lambda k: True |
| logs23 = [] |
| mgr.log = lambda a2, b: logs23.append(str(b)) |
| mgr.api = _DelAPI23() |
| mgr.journal.change(lambda dd: dd['events'].update({'rj1:S23': { |
| 'session_key': 'rj1:S23', 'name': 'rj1', 'title': 't', 'description': 'desc\nMARK23', 'privacy': 'unlisted', |
| 'date': 'd', 'time': 't', 'username': 'rj1', 'room_id': 'S23', 'broadcast_id': 'bb23', |
| 'create_pending': False, 'phase': 'closing', 'bound': True, 'was_live': False, 'closing': True, |
| 'last_poll': 0, 'offline_since': None, 'offline_count': 0, 'note': '', 'marker': 'MARK23'}})) |
| mgr.finish_event('rj1:S23') |
| _d23 = mgr.journal.read() |
| _hist23 = [h for h in (_d23.get('history') or []) if h.get('session_key') == 'rj1:S23'] |
| check('N23: بث liveStarting لم يُشغَّل أبدًا يُحذف ويُؤرشف empty_deleted — لا إنهاء معلّق يحرق مقعد السقف', |
| _deleted23 == ['bb23'] and not (_d23.get('events') or {}).get('rj1:S23') |
| and _hist23 and _hist23[0].get('outcome') == 'empty_deleted', |
| 'deleted=%s in_events=%s hist=%s' % (_deleted23, 'rj1:S23' in (_d23.get('events') or {}), |
| [(h.get('outcome')) for h in _hist23])) |
| mgr.api, mgr.log, mgr.stop_sender = _pre23_api, _pre23_log, _pre23_stop |
| mgr.journal.change(_restore23) |
|
|
| |
| _src25 = (DIR / 'app.py').read_text(encoding='utf-8') + (DIR / 'relay.py').read_text(encoding='utf-8') |
| check('N25: مسار التنفيذ بلا تسجيل/رفع أرشيف وبلا HF upload token', |
| '_bucket_upload' not in _src25 and 'HF_UPLOAD_TOKEN' not in _src25 |
| and 'huggingface_hub' not in (DIR / 'requirements.txt').read_text(encoding='utf-8'), '') |
|
|
| |
| import tiktok_auth as _ta19 |
| _orig_env19 = os.environ.get('TIKTOK_SESSIONID') |
| try: |
| _ta19.save('oldacc', 'sessionid=' + 'O' * 40) |
| os.environ['TIKTOK_SESSIONID'] = 'G' * 40 |
| _s19 = _ta19.session_for('oldacc') |
| _ok19 = _s19.get('source') == 'TIKTOK_SESSIONID' and _s19.get('sessionid') == 'G' * 40 |
| finally: |
| _ta19.delete('oldacc') |
| if _orig_env19 is None: os.environ.pop('TIKTOK_SESSIONID', None) |
| else: os.environ['TIKTOK_SESSIONID'] = _orig_env19 |
| check('N19: Secret TIKTOK_SESSIONID يتقدم على توكن UI قديم للحساب', |
| _ok19, 'source=%r' % _s19.get('source')) |
|
|
|
|
| |
| _body20 = {'data': {'liveRoom': {'status': 4}}} |
| _calls20 = [] |
| class _Resp20: |
| status_code = 200 |
| def raise_for_status(self): pass |
| def json(self): return _body20 |
| _orig_get20 = _app.requests.get |
| def _fake_get20(url, params=None, impersonate=None, headers=None, timeout=None): |
| _calls20.append(dict(headers or {}));return _Resp20() |
| _app.requests.get = _fake_get20 |
| try: |
| _r20a = _app.get_json('https://www.tiktok.com/api-live/user/room', {'aid':1988}, 'old20') |
| _ok20a = _r20a.get('data',{}).get('liveRoom',{}).get('status') == 4 |
| _ok20b = len(_calls20) == 1 and not _calls20[0].get('Cookie') |
| finally: |
| _app.requests.get = _orig_get20 |
| check('N20: الغرفة العامة تُفحص بلا Cookie أولًا ولا تُستهلك الجلسة', |
| _ok20a and _ok20b, 'calls=%r' % _calls20) |
|
|
| |
| |
| from youtube_api import Journal as _J21, DEFAULT_SETTINGS as _DS21 |
| _dir21 = tempfile.mkdtemp() |
| _p21 = pathlib.Path(_dir21) / 'j21.json' |
| _p21.write_text(json.dumps({'schema': 7, 'instance': 'x', 'enabled': False, 'channel': None, |
| 'streams': {}, 'events': {}, 'history': [], 'budget': {}, |
| 'settings': {'name': 'ك', 'privacy': 'public', 'title': '{title}', 'description': _DS21['description']}}), encoding='utf-8') |
| _j21 = _J21(_p21).read() |
| _custom21 = pathlib.Path(_dir21) / 'j21c.json' |
| _custom21.write_text(json.dumps({'schema': 7, 'instance': 'y', 'enabled': False, 'channel': None, |
| 'streams': {}, 'events': {}, 'history': [], 'budget': {}, |
| 'settings': {'name': 'ك', 'privacy': 'public', 'title': 'قالبي {name} الخاص', 'description': 'د'}}), encoding='utf-8') |
| _j21c = _J21(_custom21).read() |
| _nick21 = pathlib.Path(_dir21) / 'j21n.json' |
| _nick21.write_text(json.dumps({'schema': 7, 'instance': 'z', 'enabled': False, 'channel': None, |
| 'streams': {}, 'events': {}, 'history': [], 'budget': {}, |
| 'settings': {'name': 'ك', 'privacy': 'public', 'title': '{nickname} | بث مباشر | {date} — {time}', |
| 'description': 'د'}}), encoding='utf-8') |
| _j21n = _J21(_nick21).read() |
| _jb21 = json.loads(json.dumps(mgr.journal.read())) |
| _pre21_acc = mgr.accounts |
| _pre21 = mgr.api, mgr._observe, mgr.ensure_stream, mgr.open_event, mgr.drive_event, mgr.probe |
| _ms21 = getattr(mgr, 'manager_stop', None) |
| if _ms21 is not None: |
| _ms21.set() |
| _mt21 = getattr(mgr, 'manager_thread', None) |
| if _mt21 is not None and _mt21.is_alive(): |
| _mt21.join(timeout=5) |
| def _obs21(u, *a, **k): |
| return {'status': 'live', 'room_id': 'R21', |
| 'sources': [{'url': 'https://x/rj.flv', 'media': 'flv', 'codec': 'h264', 'label': 'hd'}], |
| 'nickname': u, 'live_title': ''} |
| mgr.accounts = lambda: ['rj1'] |
| mgr._observe = _obs21 |
| mgr.ensure_stream = lambda u: None |
| mgr.probe = lambda u, c: {'video': 'h264', 'audio': 'aac'} |
| mgr.open_event = ym.ManagedYouTube.open_event.__get__(mgr) |
| mgr.drive_event = lambda key: None |
| mgr.max_events = 3 |
| mgr._blocked403.pop('rj1:R21', None) |
| mgr.last_seen_status.pop('rj1', None) |
| mgr.auth_pause.pop('rj1', None) |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, history=[])) |
| mgr.tick() |
| _ev21 = (mgr.journal.read().get('events') or {}).get('rj1:R21') or {} |
| _t21 = str(_ev21.get('title') or '') |
| check('N21: القوالب القديمة العامة تُرحَّل للقالب البسيط، والمخصص لا يُمس، واسم المذيع يبقى في العنوان', |
| _j21['settings']['title'] == _DS21['title'] |
| and _j21c['settings']['title'] == 'قالبي {name} الخاص' |
| and _j21n['settings']['title'] == _DS21['title'] |
| and _t21.startswith('rj1 | ') and 'rj1' in _t21, |
| 'migrated=%r custom=%r nick=%r title=%r' % (_j21['settings']['title'], _j21c['settings']['title'], _j21n['settings']['title'], _t21)) |
| |
| mgr.journal.change(lambda dd: dd.update(history=[ |
| {'session_key': 'rj1:OLD', 'broadcast_id': 'bOLD', 'title': 'بث قديم', 'username': 'rj1', |
| 'nickname': 'ر', 'outcome': 'completed', 'ended_at': 1.0}, |
| {'session_key': 'rj1:NEW', 'broadcast_id': 'bNEW', 'title': 'بث جديد فخم', 'username': 'rj1', |
| 'nickname': 'ر', 'outcome': 'live_ended', 'ended_at': 2.0}])) |
| _sn22 = mgr.snapshot() |
| _h22 = _sn22.get('history') or [] |
| check('N22: /api/youtube لا يعرض سجل الأحداث القديمة أو روابطها (المشروع Relay بلا لوحة أرشيف)', |
| _h22 == [] and _sn22.get('history_count') == 0, |
| 'hist=%s count=%s' % (_h22, _sn22.get('history_count'))) |
| mgr.api, mgr._observe, mgr.ensure_stream, mgr.open_event, mgr.drive_event, mgr.probe = _pre21 |
| mgr.accounts = _pre21_acc |
| mgr.journal.change(lambda dd: dd.clear() or dd.update(_jb21)) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| check('N4: جلسة سليمة ≥25 ث تُلغي التأجيل وتمسح ملاحظته من اللوحة', |
| not mgr.retry_at and _note_now == '' and not mgr.hammer.get('recovered') |
| and any('مُسح تأجيل العقاب' in x for x in logs_n4), 'note=%r' % _note_now[:40]) |
| |
| mgr.journal.change(lambda dd: dd['events'].update({'rec:9': dict(dd['events']['rec:9'], |
| note='تيك توك أغلق الجلسة')})) |
| mgr._note_early_exit('recovered', _FeedingSender(), lasted=40.0) |
| _kept = (mgr.journal.read()['events'].get('rec:9') or {}).get('note') |
| check('N4: لا تُمسح ملاحظات الغير — البادئة شرط الحذف', _kept == 'تيك توك أغلق الجلسة', repr(_kept)[:40]) |
| mgr.journal.change(lambda dd: dd['events'].pop('rec:9', None)) |
|
|
|
|
|
|
| mgr.log = lambda u, m: logs.append(str(m)) |
| mgr.hammer.clear(); mgr.retry_at.clear(); mgr.retry.clear() |
| check('N: الرمز يُقرأ من حالة المرسل (relay.last_exit_code) لا من السجل فقط', |
| hasattr(relay.Sender(FF, lambda u, m: None, lambda u: {}), 'last_exit_code'), '') |
|
|
| |
| _pre23 = mgr.accounts, mgr._observe, mgr.ensure_stream, mgr.drive_event, mgr.remote, mgr.open_event |
| _logs23 = [] |
| _orig_log23 = mgr.log |
| mgr.log = lambda u, m: _logs23.append(str(m)) |
| def _obs23(u, *a, **k): |
| return {'status': 'live', 'room_id': 'R23', |
| 'sources': [{'url': 'https://x/a.flv', 'media': 'flv', 'codec': 'h264', 'label': 'hd'}], |
| 'nickname': u, 'live_title': ''} |
| def _remote23(resource, rid): |
| return {'id': rid, |
| 'snippet': {'title': 'same', 'description': 'x\nQUSAI-AUTO-x-EVENT-abc\n'}, |
| 'status': {'lifeCycleStatus': 'live', 'privacyStatus': 'public'}, |
| 'contentDetails': {'boundStreamId': 's1'}} |
| mgr.accounts = lambda: ['u23'] |
| mgr._observe = _obs23 |
| mgr.ensure_stream = lambda u: None |
| mgr.drive_event = lambda key: None |
| mgr.remote = _remote23 |
| def _no_open23(u, o): |
| raise RuntimeError('open_event should not run on resume') |
| mgr.open_event = _no_open23 |
| mgr.journal.change(lambda dd: dd.update(enabled=True, events={}, |
| streams={**(dd.get('streams') or {}), 'u23': {'id': 's1'}}, history=[{ |
| 'session_key': 'u23:R23', 'broadcast_id': 'b23', 'title': 'same', 'username': 'u23', |
| 'nickname': 'u23', 'outcome': 'live_ended', 'ended_at': time.time() - 400}])) |
| mgr.tick() |
| _ev23 = (mgr.journal.read().get('events') or {}).get('u23:R23') or {} |
| _h23 = mgr.journal.read().get('history') or [] |
| check('N23: جلسة أُرشفت ويوتيوب ما زال live تُستأنف على نفس الحدث ولا تُترك بلا ناشر', |
| _ev23.get('broadcast_id') == 'b23' and _ev23.get('bound') is True |
| and _ev23.get('youtube_status') == 'live' |
| and not any(h.get('session_key') == 'u23:R23' for h in _h23) |
| and any('resume same YouTube event' in x for x in _logs23), |
| 'ev=%s hist=%s logs=%s' % ({k: _ev23.get(k) for k in ('broadcast_id', 'bound', 'youtube_status', 'phase')}, |
| [(h.get('session_key'), h.get('broadcast_id')) for h in _h23], _logs23[-4:])) |
| mgr.accounts, mgr._observe, mgr.ensure_stream, mgr.drive_event, mgr.remote, mgr.open_event = _pre23 |
| mgr.log = _orig_log23 |
| mgr.journal.change(lambda dd: dd.update( |
| events={k: v for k, v in (dd.get('events') or {}).items() if k != 'u23:R23'}, |
| streams={k: v for k, v in (dd.get('streams') or {}).items() if k != 'u23'}, |
| history=[h for h in (dd.get('history') or []) if h.get('session_key') != 'u23:R23'])) |
|
|
| check('M: لا ffmpeg/قارئ متسرب بعد كل الجلسات', not stray, 'stray=%s' % stray[:1]) |
| srv.shutdown() |
| print() |
| bad = [t for t, ok in results if not ok] |
| print('النتيجة: %d/%d' % (len(results) - len(bad), len(results))) |
| if bad: |
| print('فاشل:', bad) |
| sys.exit(1) |
|
|
