Spaces:
Running
Running
Download test_watchdog.py from Reoo88/Prayer-Time-Bot: direct link, hf CLI and curl.
- Browser
- Download file 24.3 kB
-
https://huggingface.co/spaces/Reoo88/Prayer-Time-Bot/resolve/main/test_watchdog.py
- Command line
-
hf download hf://spaces/Reoo88/Prayer-Time-Bot/test_watchdog.py
-
curl -L -o test_watchdog.py https://huggingface.co/spaces/Reoo88/Prayer-Time-Bot/resolve/main/test_watchdog.py
24.3 kB
| """اختبارات حية لمنطق الحارس (watchdog) ودورة الحياة الكاملة في relay.Sender.send. | |
| تُشغَّل بأنبوب ffmpeg/ffprobe حقيقيين (لا stubs للعملية): الحالة الوحيدة التي لا تُثبت | |
| بmock هي «FFmpeg جالس ينتظر stdin» — وهنا نثبتها بFFmpeg فعلي. | |
| """ | |
| import os, pathlib, subprocess, sys, tempfile, threading, time, types | |
| 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') | |
| os.environ['YOUTUBE_SEND_MODE'] = 'copy' # لا إعادة ترميز: أسرع في الاختبار | |
| os.environ['YOUTUBE_PROGRESS_STALL_SECONDS'] = '25' | |
| sys.path.insert(0, str(DIR)) | |
| FF = os.environ.get('FFMPEG_PATH') or 'ffmpeg' | |
| FP = os.environ.get('FFPROBE_PATH') or 'ffprobe' | |
| def find_exe(name): | |
| from shutil import which | |
| return which(name) or ('/home/user/tools/' + name) | |
| FF, FP = find_exe(FF), find_exe(FP) | |
| import relay | |
| from relay import Sender, SourceStalled | |
| REAL_REQUESTS = relay.requests # الوحدة الحقيقية: كل استرجاع لاحق كان يضع دالة get مكانها (خلل في المنصة نفسها) | |
| tmp = pathlib.Path(tempfile.mkdtemp()) | |
| def make_flv(name='src.flv', size='320x240', seconds=30, codec='libx264'): | |
| out = tmp / name | |
| subprocess.run([FF, '-hide_banner', '-loglevel', 'error', '-y', '-f', 'lavfi', | |
| '-i', 'testsrc2=size=%s:rate=20' % size, '-f', 'lavfi', | |
| '-i', 'sine=frequency=440:sample_rate=48000', '-t', str(seconds), | |
| '-map', '0:v', '-map', '1:a', '-c:v', codec, '-preset', 'ultrafast', | |
| '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-ar', '48000', '-ac', '1', | |
| '-f', 'flv', str(out)], check=True, capture_output=True) | |
| return out | |
| DATA = make_flv().read_bytes() | |
| CHUNK = 8192 | |
| class FakeResponse: | |
| """استجابة HTTP تشبه curl_cffi: iter_content() يعطي قطعًا، وتنسدّ بعد N منها.""" | |
| def __init__(self, data, send_chunks=None, block_after=True): | |
| self.data = data | |
| self.n = len(data) if send_chunks is None else min(send_chunks * CHUNK, len(data)) | |
| self.block_after = block_after | |
| self.closed = 0 | |
| self.raise_on_read = False | |
| def raise_for_status(self): | |
| return None | |
| def iter_content(self, chunk_size): | |
| pos = 0 | |
| while pos < len(self.data): | |
| if self.raise_on_read: | |
| raise OSError('read timeout') | |
| buf = self.data[pos:pos + CHUNK] | |
| if not buf: | |
| break | |
| pos += len(buf) | |
| yield buf | |
| if pos >= self.n: | |
| if self.block_after: | |
| # صمت تام: لا بيانات ولا إغلاق — بالضبط ما لا يراه poll() | |
| while not self.closed: | |
| time.sleep(0.05) | |
| return | |
| return | |
| def close(self): | |
| self.closed += 1 | |
| def new_sender(logs, **kw): | |
| s = Sender(FF, lambda u, m: logs.append((time.monotonic(), str(m))), lambda u: {}) | |
| s.mode_override = 'copy' | |
| for k, v in kw.items(): | |
| setattr(s, k, v) | |
| return s | |
| CAND = {'url': 'https://cdn.example.invalid/live.flv', 'media': 'flv', 'codec': 'h264', 'label': 'hd · h264'} | |
| results = [] | |
| def check(tag, cond, extra=''): | |
| results.append((tag, bool(cond), extra)) | |
| print(' %s %s %s' % ('OK —' if cond else 'FAIL', tag, extra)) | |
| # ── A) المصدر يرسل بيانات طبيعية: الحارس لا يتدخل، والجلسة تُنهي بإيقاف عادي ────── | |
| os.environ['YOUTUBE_SOURCE_STALL_SECONDS'] = '45' | |
| logs = [] | |
| st = threading.Event() | |
| resp = FakeResponse(DATA[:200 * CHUNK]) # يكفي ليتقدّم FFmpeg ثم نوقفه | |
| sender = new_sender(logs) | |
| real_get = relay.requests.get | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k: resp) | |
| th = {} | |
| def run(): | |
| th['rc'] = sender.send('u', CAND, str(tmp / 'A.flv'), st) | |
| t = threading.Thread(target=run, daemon=True) | |
| t.start() | |
| time.sleep(6) | |
| st.set() | |
| t.join(timeout=25) | |
| alive_after = sender.alive() | |
| snap = sender.snapshot() | |
| relay.requests = REAL_REQUESTS | |
| check('A: جلسة طبيعية تُنهي بلا استثناء وبلا عمليات متبقية', | |
| not alive_after and 'Traceback' not in str(th) and th.get('rc', True) in (True, False) | |
| and snap['source_bytes'] > 0, 'bytes=%d out=%s' % (snap['source_bytes'], snap['output_seconds'])) | |
| check('A: لا رسائل إنذار كاذبة في السجل', | |
| not any('توقف المصدر' in m for _, m in logs), 'log=%d' % len(logs)) | |
| check('A: وسوم اللوغات المطلوبة حاضرة', any('[RELAY]' in m for _, m in logs) and any('[CLEANUP]' in m for _, m in logs)) | |
| # ── B) المصدر يصمت والعملية حية: الحارس يرفع SourceStalled خلال المهلة ───────────── | |
| os.environ['YOUTUBE_SOURCE_STALL_SECONDS'] = '4' | |
| logs = [] | |
| st = threading.Event() | |
| resp = FakeResponse(DATA, send_chunks=40, block_after=True) | |
| sender = new_sender(logs) | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k: resp) | |
| err = {} | |
| def run_b(): | |
| try: | |
| sender.send('u', CAND, str(tmp / 'B.flv'), st) | |
| err['exc'] = None | |
| except BaseException as e: | |
| err['exc'] = e | |
| t0 = time.monotonic() | |
| t = threading.Thread(target=run_b, daemon=True) | |
| t.start() | |
| t.join(timeout=40) | |
| dur = time.monotonic() - t0 | |
| relay.requests = REAL_REQUESTS | |
| check('B: صمت المصدر يُكتشف بالحارس (لا poll/لا رمز خروج)', | |
| isinstance(err.get('exc'), SourceStalled) and 3.0 < dur < 15.0, | |
| 'exc=%s بعد %.1fs' % (type(err.get('exc')).__name__, dur)) | |
| check('B: FFmpeg لا يبقى معلّقًا بعد اكتشاف الصمت', not sender.alive()) | |
| check('B: الاستجابة أُغلقت فعليًا', resp.closed > 0, 'close()×%d' % resp.closed) | |
| wd_ts = [tt for tt, m in logs if '[WATCHDOG] توقف المصدر' in m] | |
| cl_ts = [tt for tt, m in logs if '[CLEANUP]' in m] | |
| check('B: رسالة [WATCHDOG] ثم [CLEANUP] بالترتيب', | |
| bool(wd_ts) and bool(cl_ts) and max(wd_ts) <= min(cl_ts), | |
| 'wd=%d cleanup=%d' % (len(wd_ts), len(cl_ts))) | |
| # ── C) عملية المصدر (القارئ) ماتت/انتهت: الحلقة تخرج ولا تُعلّق ──────────────────── | |
| os.environ['YOUTUBE_SOURCE_STALL_SECONDS'] = '0' # بلا حارس: الإعتماد على إغلاق الاستجابة | |
| logs = [] | |
| st = threading.Event() | |
| resp = FakeResponse(DATA[:20 * CHUNK], block_after=False) # StopIteration = نهاية البث | |
| sender = new_sender(logs) | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k: resp) | |
| t = threading.Thread(target=lambda: sender.send('u', CAND, str(tmp / 'C.flv'), st), daemon=True) | |
| t.start() | |
| t.join(timeout=30) | |
| relay.requests = REAL_REQUESTS | |
| check('C: إغلاق الاستجابة يُنهي الجلسة بلا تعليق وبلا استثناء', not t.is_alive() and not sender.alive()) | |
| check('C: السجل يشرح أنه إغلاق من المصدر', any('أغلق تيك توك الاستجابة' in m for _, m in logs)) | |
| # ── D) FFmpeg يموت مبكرًا (وجهة مرفوضة/غير صالحة): لا خيوط معلقة ────────────────── | |
| logs = [] | |
| st = threading.Event() | |
| sender = new_sender(logs) | |
| try: | |
| rc = sender.send('u', CAND, str(tmp / 'no-such-dir' / 'D.flv'), st) | |
| crash = None | |
| except BaseException as e: | |
| rc, crash = None, e | |
| check('D: FFmpeg لم يولد ⇒ RelayStartError بلا عملية أو جلسة معلقة', | |
| not sender.alive() and isinstance(crash, relay.RelayStartError) and sender.session is None, | |
| 'rc=%s crash=%s' % (rc, type(crash).__name__ if crash else '-')) | |
| # ── E) بعد صمت قصير يعود التدفق: الجلسة تستمر (الحارس لا يقطع بثًا يتنفس) ───────── | |
| os.environ['YOUTUBE_SOURCE_STALL_SECONDS'] = '6' | |
| logs = [] | |
| st = threading.Event() | |
| class FlakyResponse(FakeResponse): | |
| def iter_content(self, chunk_size): | |
| pos = 0 | |
| while pos < len(self.data): | |
| buf = self.data[pos:pos + CHUNK] | |
| pos += len(buf) | |
| yield buf | |
| if pos == 60 * CHUNK: | |
| time.sleep(3.5) # وقفة CDN قصيرة (أقل من المهلة) | |
| if self.closed: | |
| return | |
| resp = FlakyResponse(DATA[:200 * CHUNK]) | |
| sender = new_sender(logs) | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k: resp) | |
| out = {} | |
| t = threading.Thread(target=lambda: out.setdefault('rc', sender.send('u', CAND, str(tmp / 'E.flv'), st)), daemon=True) | |
| t.start() | |
| time.sleep(12) | |
| relay_time = sender.snapshot()['output_seconds'] | |
| check('E: وقفة 3.5ث أصغر من المهلة ⇒ البث استمر وتقدّم', | |
| relay_time > 0, 'out_time=%.1fs' % relay_time) | |
| st.set() | |
| t.join(timeout=25) | |
| relay.requests = REAL_REQUESTS | |
| check('E: لا إنذار كاذب أثناء الوقفة القصيرة', not any('[WATCHDOG] توقف المصدر' in m for _, m in logs)) | |
| # ── F) التنظيف لا يترك children: لا ffmpeg حيّ بعد كل جلسة أعلاه ───────────────── | |
| mine = subprocess.run(['ps', '-eo', 'pid,args'], capture_output=True, text=True).stdout.splitlines() | |
| stray = [l for l in mine if 'lavfi' in l or (str(tmp) in l and 'ffmpeg' in l)] | |
| check('F: لا عملية ffmpeg/قارئ متسربة بعد 5 جلسات', not stray, 'stray=%s' % stray[:1]) | |
| check('F: الحالة الداخلية نظيفة', sender.session is None and sender.process is None) | |
| # ── G) لا جلستان متزامنتان لنفس المرسل (send متسلسل، والحارس لا يقاتل المستخدم) ─── | |
| os.environ['YOUTUBE_SOURCE_STALL_SECONDS'] = '3' | |
| logs = [] | |
| resp = FakeResponse(DATA, send_chunks=100000, block_after=True) | |
| sender = new_sender(logs) | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k: resp) | |
| st2 = threading.Event() | |
| t1 = threading.Thread(target=lambda: sender.send('u', CAND, str(tmp / 'G1.flv'), st2), daemon=True) | |
| t1.start() | |
| time.sleep(4) | |
| snap_mid = sender.snapshot() | |
| t1_running = t1.is_alive() | |
| st2.set() # «إيقاف من الواجهة» أثناء صمت المصدر | |
| t1.join(timeout=20) | |
| relay.requests = REAL_REQUESTS | |
| check('G: إيقاف المستخدم يُفيق الخيط المعلّق فورًا (لا انتظار المهلة)', | |
| not t1.is_alive() and snap_mid['source_bytes'] > 0, | |
| 'bytes=%d age=%s' % (snap_mid['source_bytes'], snap_mid.get('source_age'))) | |
| check('G: لا جلسة ثانية تُبنى قبل انتهاء الأولى', sender.session is None and sender.process is None) | |
| # B2) صمت المصدر قبل القفل يُقاس: لا يُعاقَب يوتيوب على جوع تيك توك | |
| os.environ['YOUTUBE_SOURCE_STALL_SECONDS'] = '4' | |
| logs_b2 = [] | |
| st_b2 = threading.Event() | |
| resp_b2 = FakeResponse(DATA, send_chunks=30, block_after=True) | |
| sender_b2 = new_sender(logs_b2) | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k: resp_b2) | |
| err_b2 = {} | |
| def run_b2(): | |
| try: | |
| sender_b2.send('u', CAND, str(tmp / 'B2.flv'), st_b2) | |
| err_b2['exc'] = None | |
| except BaseException as e: # noqa: BLE001 | |
| err_b2['exc'] = e | |
| t_b2 = threading.Thread(target=run_b2, daemon=True) | |
| t_b2.start() | |
| t_b2.join(timeout=40) | |
| relay.requests = types.SimpleNamespace(get=real_get) | |
| gap_b2 = getattr(sender_b2, 'last_source_gap', -1.0) | |
| check('B2: الفجوة بين آخر بايت ونهاية الجلسة موثّقة في المرسل (لا يُتهم المستقبِل بلا دليل)', | |
| gap_b2 >= 2.0 and isinstance(err_b2.get('exc'), SourceStalled), | |
| 'gap=%s exc=%s' % (gap_b2, type(err_b2.get('exc')).__name__)) | |
| snap_b2 = sender_b2.snapshot() | |
| check('B2: الحالة تحمل source_gap لتُقرأ في /api/state واللوحة', | |
| float(snap_b2.get('source_gap') or 0) >= 2.0, str(snap_b2.get('source_gap'))) | |
| # زمن التفكيك مقاسًا: لا يكفي أن يكتشف الحارس الصمت، يجب أن يُنهي الجلسة بسرعة لأن كل ثانية | |
| # هنا هي ثوانٍ بلا صورة عند المشاهدين (قياس سابق على الحيّ: 11 ث بين الاكتشاف و[CLEANUP]). | |
| _ts = {m[:24]: tt for tt, m in logs_b2} | |
| t_detect = next((tt for tt, m in logs_b2 if '[WATCHDOG] توقف المصدر' in m), None) | |
| t_clean = next((tt for tt, m in logs_b2 if '[CLEANUP] أُوقف FFmpeg' in m and t_detect and tt >= t_detect), None) | |
| teardown_s = (t_clean - t_detect) if (t_detect and t_clean) else 999.0 | |
| check('B3: التفكيك بعد الاكتشاف ≤ 6 ث (كان 11 ث: wait(10) ثم kill ثم wait(5))', | |
| teardown_s <= 6.0, 'teardown=%.1f ث' % teardown_s) | |
| # ── A2) إعلان fourCcLive: على الترميز المدفوع لا على الوضع ───────────────────────── | |
| # الإعلان الكاذب (hvc1 على تدفق h264) هو ما يجعل حافة يوتيوب تقفل النشر بعد ثوانٍ مع noData، | |
| # فالقطعة مقيسة على باني الأوامر نفسه: نسخة h264 ⇒ لا إعلان، نسخة h265 ⇒ إعلان، off ⇒ لا شيء. | |
| import os as _os | |
| _os.environ['YOUTUBE_SEND_MODE'] = 'copy' | |
| _s_h264 = new_sender(logs).command('rtmps://x/live/K', {'codec': 'h264', 'label': 'hd · h264'}) | |
| _s_h265 = new_sender(logs).command('rtmps://x/live/K', {'codec': 'hevc', 'label': 'origin · h265'}) | |
| _os.environ['YOUTUBE_ENHANCED_RTMP'] = 'off' | |
| _s_off = new_sender(logs).command('rtmps://x/live/K', {'codec': 'hevc', 'label': 'origin · h265'}) | |
| _os.environ.pop('YOUTUBE_ENHANCED_RTMP', None) | |
| check('A2: نسخة h264 لا تُعلن hvc1 على حافة الاستقبال', | |
| '-rtmp_enhanced_codecs' not in ' '.join(_s_h264), ' '.join(_s_h264)[:120]) | |
| check('A2: نسخة h265 تُعلن hvc1 (الإعلان لجمهور النسخ المعزّز فعلًا)', | |
| '-rtmp_enhanced_codecs' in ' '.join(_s_h265), ' '.join(_s_h265)[:120]) | |
| check('A2: HEVC يمر stream-copy ولا يدخل libx264', | |
| '-c:v copy' in ' '.join(_s_h265) and 'libx264' not in _s_h265, ' '.join(_s_h265)[:160]) | |
| check('A2: YOUTUBE_ENHANCED_RTMP=off يلغي الإعلان حتى مع h265', | |
| '-rtmp_enhanced_codecs' not in ' '.join(_s_off), ' '.join(_s_off)[:120]) | |
| check('A2: ملف محلي لا يأخذ خيارات بروتوكول rtmp', | |
| '-rtmp_enhanced_codecs' not in ' '.join(new_sender(logs).command(str(tmp / 'z.flv'), {'codec': 'hevc'})), '') | |
| # ── A3) معدل حي ثابت حقيقي: لا CRF مقنّعًا بعنوان 4500k ─────────────────────────── | |
| # قياس الأمر السابق على لون ساكن 720x1280/30: 14.12 kbit/s فقط رغم -b:v 4500k، ثم | |
| # videoIngestionStarved من يوتيوب للحسابين. nal-hrd=cbr + minrate أعطيا 4443.72 kbit/s. | |
| _s_cbr = new_sender(logs, mode_override='matchgop').command( | |
| 'rtmps://x/live/K', {'codec': 'h264', 'label': 'hd · h264', 'width': 720, 'height': 1280}) | |
| _j_cbr = ' '.join(_s_cbr) | |
| check('A3: التحويل يطلب CBR صريحًا: bitrate=minrate=maxrate ولا CRF متعارض', | |
| '-b:v 4500k -minrate 4500k -maxrate 4500k' in _j_cbr and '-crf' not in _s_cbr, | |
| _j_cbr[:180]) | |
| check('A3: x264 يملأ المشاهد الساكنة ويحافظ على CFR عند بوابة يوتيوب', | |
| any(a.startswith('nal-hrd=cbr:force-cfr=1:') for a in _s_cbr), | |
| next((a for a in _s_cbr if 'nal-hrd' in a), 'missing')) | |
| _os.environ['YOUTUBE_SEND_MODE'] = 'copy' | |
| # ── H) مرصد سبب الإغلاق: stderr من FFmpeg الحقيقي يصل مصنَّفًا ومُخفًى ───────────── | |
| # الإنتاج قال «لم يظهر سبب مصنّف» لست جلسات متتالية. هذه الفحوصات تُثبت أن ما يقوله FFmpeg | |
| # فعلًا يُصنَّف ويُخزَّن ويُطبع، وأن المفتاح والرابط لا يخرجان من الإخفاء أبدًا. | |
| os.environ['YOUTUBE_SOURCE_STALL_SECONDS'] = '20' | |
| logs_h = [] | |
| st_h = threading.Event() | |
| resp_h = FakeResponse(b'FLV\x09\x00\x00\x00\x00\x01\x00\x00\x00' + os.urandom(6000)) | |
| sender_h = new_sender(logs_h) | |
| _got_h = relay.requests.get | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k: resp_h) | |
| try: | |
| sender_h.send('u', CAND, str(tmp / 'H.flv'), st_h) | |
| except Exception as e: | |
| logs_h.append((time.monotonic(), 'exc ' + repr(e))) | |
| relay.requests = REAL_REQUESTS | |
| _snap_h = sender_h.snapshot() | |
| _raw_txt = ' '.join(_snap_h.get('ffmpeg_errors') or []) | |
| check('H: مصدر تالف ← وصف مصنَّف يصل إلى الحالة (لا «لم يظهر سبب» كاذبًا)', | |
| bool(_snap_h.get('ffmpeg_diagnostics')) or any('خرج برمز' in m for _, m in logs_h), | |
| 'diag=%s' % (_snap_h.get('ffmpeg_diagnostics') or [])[:1]) | |
| check('H: سطر FFmpeg الخام يُحتفظ به بعد الإخفاء ليقرأه المشرف', | |
| bool(_snap_h.get('ffmpeg_errors')), 'raw=%d' % len(_snap_h.get('ffmpeg_errors') or [])) | |
| check('H: لا تسريب لروابط البث أو المفاتيح في ما يُطبع', | |
| 'cdn.example.invalid' not in _raw_txt and 'live.flv' not in _raw_txt, _raw_txt[:80]) | |
| # نفس السطور التي يكتب FFmpeg فعلًا (تهجيه، لا تهجئتنا) — فحص النص الثابت على الدوال المشحّنة | |
| from relay import classify_ffmpeg_error as _cls, redact_stderr as _red | |
| _dts = '[flv @ 0x55f7c1] Non-monotonous DTS in output stream 0:1; ignoring. This may give invalid output.' | |
| check('H: FFmpeg يقول Non-monotonous (بهذه التهجئة) والمصنِّف يلتقطها', | |
| 'DTS' in (_cls(_dts) or ''), _cls(_dts) or '') | |
| _bad = _red('rtmps://s-abc.rtmp.youtube.com:443/live/AAAA-BBBB-CCCC key=SUPERSECRET123 Non-monotono') | |
| check('H: الإخفاء يمسح الرابط والمفتاح ويُبقي السبب', | |
| all(x not in _bad for x in ('s-abc.rtmp.youtube.com', 'AAAA-BBBB-CCCC', 'SUPERSECRET123')) and 'Non-monotono' in _bad, | |
| _bad[:70]) | |
| _yt = _cls('RTMP_SendPacket error: Application defined reason: Publish Stream is not allowed') | |
| check('H: رسالة الرفض من خادم يوتيوب لها اسم عربي في اللوحة', bool(_yt), _yt or '') | |
| # ── I) أول بايت تصل إلى الوجهة: الحجز الأولي كان يبتلع عمر الجلسة كله ────────────── | |
| # مقياسٌ على الإنتاج أن الحافة تقفل بعد 13-20 ث، و`-timeshift 10` كان يؤخّر أول بايت إلى | |
| # 10.0 ث — فتبقى الجلسة كلها شبه فارغة عند يوتيوب (health=noData أبدي). نعيد نفس القياس هنا | |
| # على الأمر الذي تبنيه الشيفرة فعلًا، بملف محلي بدل rtmps (نفس الخيارات، مِخرَج يمكن قياسه). | |
| def first_byte_delay(args, feed_seconds=16.0): | |
| out_path = tmp / ('first-%d.flv' % int(time.monotonic() * 1000)) | |
| args = [str(out_path) if a == 'rtmps://fake.example.invalid/live/KEY' else a for a in args] | |
| proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, | |
| stderr=subprocess.DEVNULL, bufsize=0) | |
| def feed(): | |
| # تغذية مستمرة بلا نهاية خلال نافذة القياس: لو انتهى المدخل قبل نهاها لأخرج FFmpeg | |
| # مخزنه عند EOF فقرأنا «نموًا» عند 1.8 ث وهو في الحقيقة تفريغ نهاية، لا أول بايت حيّة. | |
| step = 300000 | |
| i = 0 | |
| while proc.poll() is None: | |
| buf = DATA[i:i + step] | |
| if not buf: | |
| i = 0 # نعيد الحلقة: المصدر حيّ فلا يجفّ التدفق | |
| continue | |
| try: | |
| proc.stdin.write(buf) | |
| proc.stdin.flush() | |
| except (BrokenPipeError, ValueError, OSError): | |
| return | |
| i += step | |
| time.sleep(0.30) | |
| ft = threading.Thread(target=feed, daemon=True) | |
| ft.start() | |
| t0 = time.monotonic() | |
| first = None | |
| while time.monotonic() - t0 < feed_seconds: | |
| if out_path.exists() and out_path.stat().st_size > 0: | |
| first = time.monotonic() - t0 | |
| break | |
| time.sleep(0.1) | |
| try: | |
| proc.kill() | |
| except OSError: | |
| pass | |
| try: | |
| proc.stdin.close() | |
| except OSError: | |
| pass | |
| return first | |
| os.environ.pop('YOUTUBE_FIFO_TIMESHIFT', None) | |
| _s_fast = new_sender([]).command('rtmps://fake.example.invalid/live/KEY', {'codec': 'h264', 'label': 'hd · h264'}) | |
| _d_fast = first_byte_delay(_s_fast) | |
| check('I: مع الإعداد الافتراضي أول بايت تصل خلال ≤3 ث (بلا حجز أولي)', | |
| _d_fast is not None and _d_fast <= 3.0, 'first=%.1f ث' % (_d_fast if _d_fast is not None else -1)) | |
| os.environ['YOUTUBE_FIFO_TIMESHIFT'] = '12' | |
| _s_slow = new_sender([]).command('rtmps://fake.example.invalid/live/KEY', {'codec': 'h264', 'label': 'hd · h264'}) | |
| _d_slow = first_byte_delay(_s_slow, feed_seconds=14.0) | |
| # الزمان هنا قياسٌ نسبي لا مطلق: التغذية تدور على نفس الملف فتعود الطوابع الزمنية إلى الوراء، | |
| # ومُخرَج fifo يؤخّر بمقدار «زمن البث» لا «زمن الحائط». القياس المطلق موثّق في FINDINGS | |
| # (أول بايت عند 1.1 ث بلا حجز، وعند 9.9 ث مع حجز 12 ث، على ملف 720x1280/30 ث بتغذية لا تدور). | |
| check('I: من يفعّل الحجز ينتظر فعلًا أكثر من الافتراضي (الدرع اختياري لا مفروض)', | |
| _d_slow is None or _d_slow > _d_fast, 'fast=%.1f slow=%s' % (_d_fast, '%.1f' % _d_slow if _d_slow is not None else '>16')) | |
| os.environ.pop('YOUTUBE_FIFO_TIMESHIFT', None) | |
| _joined = ' '.join(_s_slow) | |
| check('I: مع الحجز يبقى الطابور صريحًا وإهدار الحزم مفعّلًا (تركيب مدروس لا نصف إصلاح)', | |
| '-timeshift 12' in _joined and '-queue_size' in _joined and '-drop_pkts_on_overflow 1' in _joined, '') | |
| check('I: بلا حجز يكون الخرج FLV مباشرًا؛ لا fifo مخفي يكذب في out_time أو يحبس المصدر', | |
| '-timeshift' not in ' '.join(_s_fast) and '-queue_size' not in ' '.join(_s_fast) | |
| and '-drop_pkts_on_overflow' not in ' '.join(_s_fast) and '-f flv' in ' '.join(_s_fast), '') | |
| # ── K) مُبلِّغ الاستقرار: يُخبر المدير أن الحافة قبلتنا، مرة واحدة، وهو حيّ ────────── | |
| os.environ['YOUTUBE_STABLE_SECONDS'] = '1' | |
| logs_k = [] | |
| st_k = threading.Event() | |
| resp_k = FakeResponse(DATA[:120 * CHUNK]) | |
| sender_k = new_sender(logs_k) | |
| calls_k = [] | |
| sender_k.on_stable = lambda u: calls_k.append(u) | |
| relay.requests = types.SimpleNamespace(get=lambda *a, **k2: resp_k) | |
| tk = threading.Thread(target=lambda: sender_k.send('u', CAND, str(tmp / 'K.flv'), st_k), daemon=True) | |
| tk.start() | |
| time.sleep(5) | |
| st_k.set() | |
| tk.join(timeout=20) | |
| relay.requests = REAL_REQUESTS | |
| check('K: أول ثوانٍ مُسلَّمة تُبلِّغ المدير مرة واحدة فقط (لا عند موت الجلسة)', | |
| calls_k == ['u'], 'calls=%s' % calls_k) | |
| check('K: لا جلسة تُقتل بسبب المُبلِّغ نفسه', sender_k.snapshot().get('source_bytes', 0) > 0, | |
| 'bytes=%s' % sender_k.snapshot().get('source_bytes')) | |
| os.environ.pop('YOUTUBE_STABLE_SECONDS', None) | |
| 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 if bad else 0) | |