quapp-common 0.0.13.dev7__tar.gz → 0.0.13.dev8__tar.gz

{quapp_common-0.0.13.dev7/quapp_common.egg-info → quapp_common-0.0.13.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.13.dev7
+Version: 0.0.13.dev8
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.13.dev7"
+version = "0.0.13.dev8"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]

quapp_common-0.0.13.dev8/quapp_common/component/backend/job_heartbeat.py

@@ -0,0 +1,83 @@
+#  Quapp Platform Project
+#  job_heartbeat.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import os
+import threading
+
+import requests
+
+from ...config.logging_config import logger
+
+DEFAULT_INTERVAL_SEC = 30.0
+REQUEST_TIMEOUT_SEC = 5.0
+TERMINAL_STATUSES = ('DONE', 'FAILED')
+
+_lock = threading.Lock()
+_thread = None
+_stop_event = threading.Event()
+
+
+def heartbeat_interval_sec() -> float:
+    raw = os.getenv('HEARTBEAT_INTERVAL_SEC', '')
+    try:
+        value = float(raw)
+        if value > 0:
+            return value
+    except ValueError:
+        pass
+    return DEFAULT_INTERVAL_SEC
+
+
+def beat_once() -> int:
+    from .job_manager import JobManager, META, STATUS, SCHEDULER_CALLBACK_URL
+
+    sent = 0
+    for job_id, data in JobManager.list_jobs().items():
+        if data.get(STATUS) in TERMINAL_STATUSES:
+            continue
+        url = (data.get(META) or {}).get(SCHEDULER_CALLBACK_URL)
+        if not url:
+            continue
+        try:
+            response = requests.patch(
+                    url, json={'status': 'RUNNING', 'heartbeat': True},
+                    timeout=REQUEST_TIMEOUT_SEC)
+            logger.debug(
+                    f'Heartbeat for job {job_id} returned {response.status_code}')
+            sent += 1
+        except Exception as exception:
+            logger.debug(f'Heartbeat for job {job_id} failed: {exception}')
+    return sent
+
+
+def _run() -> None:
+    while True:
+        try:
+            beat_once()
+        except Exception as exception:
+            logger.exception(f'Heartbeat loop error: {exception}')
+        if _stop_event.wait(heartbeat_interval_sec()):
+            return
+
+
+def ensure_started() -> None:
+    global _thread
+    with _lock:
+        if _thread is not None and _thread.is_alive():
+            return
+        _stop_event.clear()
+        _thread = threading.Thread(target=_run, name='job-heartbeat',
+                                   daemon=True)
+        _thread.start()
+        logger.info(
+                f'Job heartbeat started with interval {heartbeat_interval_sec()}s')
+
+
+def stop() -> None:
+    global _thread
+    with _lock:
+        _stop_event.set()
+        if _thread is not None:
+            _thread.join(timeout=1.0)
+        _thread = None

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev8}/quapp_common/component/backend/job_manager.py

@@ -66,6 +66,9 @@ class JobManager:
         """
         Stop any listener threads in this process and shutdown Manager.
         """
+        from .job_heartbeat import stop
+        stop()
+
         # stop listeners
         for key, (t, stop_ev) in list(cls._listener_threads.items()):
             stop_ev.set()
@@ -100,6 +103,9 @@ class JobManager:
         cls._jobs[job_id] = data  # proxy is process-safe
         cls._publish(job_id, {"event": "added", **data})
 
+        from .job_heartbeat import ensure_started
+        ensure_started()
+
     @classmethod
     def update_status(cls, job_id: str, status: str,
                       meta_update: Optional[Dict[str, Any]] = None) -> None:

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev8/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.13.dev7
+Version: 0.0.13.dev8
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev8}/quapp_common.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ quapp_common/component/backend/__init__.py
 quapp_common/component/backend/invocation.py
 quapp_common/component/backend/job_fetcher.py
 quapp_common/component/backend/job_fetching.py
+quapp_common/component/backend/job_heartbeat.py
 quapp_common/component/backend/job_manager.py
 quapp_common/component/callback/__init__.py
 quapp_common/component/callback/update_job_metadata.py
@@ -83,6 +84,7 @@ quapp_common/util/http_utils.py
 quapp_common/util/json_parser_utils.py
 quapp_common/util/response_utils.py
 tests/test_circuit_adapter.py
+tests/test_job_heartbeat.py
 tests/test_json_parser_utils.py
 tests/test_language_dispatcher.py
 tests/test_result_serializer.py

quapp_common-0.0.13.dev8/tests/test_job_heartbeat.py

@@ -0,0 +1,115 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from quapp_common.component.backend import job_heartbeat
+from quapp_common.component.backend.job_manager import JobManager
+
+
+class TestHeartbeatInterval(unittest.TestCase):
+    def test_default_interval(self):
+        with patch.dict('os.environ', {}, clear=False):
+            import os
+            os.environ.pop('HEARTBEAT_INTERVAL_SEC', None)
+            self.assertEqual(job_heartbeat.heartbeat_interval_sec(),
+                             job_heartbeat.DEFAULT_INTERVAL_SEC)
+
+    def test_env_override(self):
+        with patch.dict('os.environ', {'HEARTBEAT_INTERVAL_SEC': '10'}):
+            self.assertEqual(job_heartbeat.heartbeat_interval_sec(), 10.0)
+
+    def test_invalid_env_falls_back(self):
+        with patch.dict('os.environ', {'HEARTBEAT_INTERVAL_SEC': 'abc'}):
+            self.assertEqual(job_heartbeat.heartbeat_interval_sec(),
+                             job_heartbeat.DEFAULT_INTERVAL_SEC)
+
+    def test_non_positive_env_falls_back(self):
+        with patch.dict('os.environ', {'HEARTBEAT_INTERVAL_SEC': '0'}):
+            self.assertEqual(job_heartbeat.heartbeat_interval_sec(),
+                             job_heartbeat.DEFAULT_INTERVAL_SEC)
+
+
+class TestBeatOnce(unittest.TestCase):
+    def setUp(self):
+        for job_id in list(JobManager.list_jobs()):
+            JobManager.remove_job(job_id)
+
+    def tearDown(self):
+        for job_id in list(JobManager.list_jobs()):
+            JobManager.remove_job(job_id)
+        job_heartbeat.stop()
+
+    def test_beats_active_job_with_url(self):
+        JobManager.add_job('job-active', status='RUNNING', meta={
+            'scheduler_callback_url': 'http://scheduler/v1/callbacks/job-active?gen=2'})
+        with patch.object(job_heartbeat.requests, 'patch',
+                          return_value=MagicMock(status_code=200)) as mock_patch:
+            sent = job_heartbeat.beat_once()
+        self.assertEqual(sent, 1)
+        mock_patch.assert_called_once_with(
+                'http://scheduler/v1/callbacks/job-active?gen=2',
+                json={'status': 'RUNNING', 'heartbeat': True},
+                timeout=job_heartbeat.REQUEST_TIMEOUT_SEC)
+
+    def test_skips_terminal_jobs(self):
+        JobManager.add_job('job-done', status='DONE', meta={
+            'scheduler_callback_url': 'http://scheduler/v1/callbacks/job-done'})
+        JobManager.add_job('job-failed', status='FAILED', meta={
+            'scheduler_callback_url': 'http://scheduler/v1/callbacks/job-failed'})
+        with patch.object(job_heartbeat.requests, 'patch') as mock_patch:
+            sent = job_heartbeat.beat_once()
+        self.assertEqual(sent, 0)
+        mock_patch.assert_not_called()
+
+    def test_skips_job_without_url(self):
+        JobManager.add_job('job-no-url', status='RUNNING', meta={})
+        with patch.object(job_heartbeat.requests, 'patch') as mock_patch:
+            sent = job_heartbeat.beat_once()
+        self.assertEqual(sent, 0)
+        mock_patch.assert_not_called()
+
+    def test_network_error_does_not_raise(self):
+        JobManager.add_job('job-net', status='RUNNING', meta={
+            'scheduler_callback_url': 'http://scheduler/v1/callbacks/job-net'})
+        with patch.object(job_heartbeat.requests, 'patch',
+                          side_effect=ConnectionError('down')):
+            sent = job_heartbeat.beat_once()
+        self.assertEqual(sent, 0)
+
+    def test_pending_job_is_beaten(self):
+        JobManager.add_job('job-pending', status='PENDING', meta={
+            'scheduler_callback_url': 'http://scheduler/v1/callbacks/job-pending'})
+        with patch.object(job_heartbeat.requests, 'patch',
+                          return_value=MagicMock(status_code=200)) as mock_patch:
+            sent = job_heartbeat.beat_once()
+        self.assertEqual(sent, 1)
+
+
+class TestDaemonLifecycle(unittest.TestCase):
+    def tearDown(self):
+        job_heartbeat.stop()
+        for job_id in list(JobManager.list_jobs()):
+            JobManager.remove_job(job_id)
+
+    def test_ensure_started_is_idempotent(self):
+        job_heartbeat.ensure_started()
+        first = job_heartbeat._thread
+        job_heartbeat.ensure_started()
+        self.assertIs(job_heartbeat._thread, first)
+        self.assertTrue(first.is_alive())
+
+    def test_stop_terminates_thread(self):
+        job_heartbeat.ensure_started()
+        thread = job_heartbeat._thread
+        job_heartbeat.stop()
+        self.assertFalse(thread.is_alive())
+        self.assertIsNone(job_heartbeat._thread)
+
+    def test_add_job_starts_daemon(self):
+        job_heartbeat.stop()
+        JobManager.add_job('job-autostart', status='RUNNING', meta={})
+        self.assertIsNotNone(job_heartbeat._thread)
+        self.assertTrue(job_heartbeat._thread.is_alive())
+
+
+if __name__ == '__main__':
+    unittest.main()