pyobs-core 2.0.0.dev89__tar.gz → 2.0.0.dev90__tar.gz

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev90}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-core
-Version: 2.0.0.dev89
+Version: 2.0.0.dev90
 Summary: robotic telescope software
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev90}/pyobs/robotic/storage/backend/observationarchive.py

@@ -32,6 +32,7 @@ class BackendObservationArchive(ObservationArchive):
         self._mode = mode
         self._aiohttp_session: aiohttp.ClientSession | None = None
         self._last_update: Time | None = None
+        self._last_marker: Time | None = None
         self._observations = ObservationList()
 
         if auto_update:
@@ -56,30 +57,41 @@ class BackendObservationArchive(ObservationArchive):
         return self._aiohttp_session
 
     async def _check_for_changes(self) -> None:
-        """Update schedule in background."""
+        """Update schedule in background, gated on the backend's update marker."""
 
         while True:
             try:
-                await self._update()
+                await self._poll()
             except Exception as e:
                 log.error("Failed to update observations from backend: %s", e)
             await asyncio.sleep(5)
 
+    async def _poll(self) -> None:
+        """Re-download the schedule when the backend's ``last_observation_update`` marker moved.
+
+        The marker is a DB-derived ``Max(updated_at)`` (pyobs-robotic-backend#84), truthful across
+        gunicorn workers, so it is a safe refresh gate; see ``BackendTaskArchive._poll``. The
+        content comparison in :meth:`_update` still decides whether to fire ``on_tasks_changed``.
+        """
+        last_update = await self.last_update_time()
+        if self._last_marker is None or last_update > self._last_marker:
+            await self._update()
+            self._last_marker = last_update
+
     async def _update(self) -> None:
         """Fetch the schedule from the backend and apply it if anything changed.
 
-        Re-fetches unconditionally on every poll instead of gating on the backend's
-        ``last_observation_update`` marker (per-process Django ``LocMemCache``, unreliable across
-        gunicorn workers -- see ``BackendTaskArchive``). Changes are detected by comparing full
-        observation contents via ``model_dump(use_task_id=True)``, keyed by observation ID so a
-        stable reordering of the same items is not mistaken for a change: the backend serializes
-        ``task`` as a plain FK ID, while cached copies get their ``task`` replaced by a full
-        ``Task`` when the mastermind calls ``fetch_task()``, so the ID normalization keeps both
-        sides comparable. The comparison includes ``state`` (``Observation.__eq__`` ignores it),
-        which matters for in-set transitions such as ``pending`` -> ``in_progress``; observations
-        leaving the fetched set -- e.g. ``window_expired``, which the server-side ``state``/
-        ``end_after`` filters drop -- are picked up as list shrinkage by the unconditional
-        refetch.
+        Called by :meth:`_poll` after the backend marker moved (or on the first poll). Changes are
+        detected by comparing full observation contents via ``model_dump(use_task_id=True)``,
+        keyed by observation ID so a stable reordering of the same items is not mistaken for a
+        change: the backend serializes ``task`` as a plain FK ID, while cached copies get their
+        ``task`` replaced by a full ``Task`` when the mastermind calls ``fetch_task()``, so the ID
+        normalization keeps both sides comparable. The comparison includes ``state``
+        (``Observation.__eq__`` ignores it), which matters for in-set transitions such as
+        ``pending`` -> ``in_progress``; observations leaving the fetched set -- e.g.
+        ``window_expired``, which the server-side ``state``/``end_after`` filters drop -- are
+        picked up as list shrinkage on the next marker-triggered refetch (the ``mark_window_expired``
+        sweep stamps ``updated_at``, so expiry moves the marker within one sweep interval).
         """
         observations = await self._get_schedule()
         if {o.id: o.model_dump(use_task_id=True) for o in observations} != {

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev90}/pyobs/robotic/storage/backend/taskarchive.py

@@ -28,6 +28,7 @@ class BackendTaskArchive(TaskArchive):
         self._token = token
         self._aiohttp_session: aiohttp.ClientSession | None = None
         self._last_update: Time | None = None
+        self._last_marker: Time | None = None
         self._projects: list[Project] = list()
         self._tasks: list[Task] = list()
 
@@ -53,26 +54,38 @@ class BackendTaskArchive(TaskArchive):
         return self._aiohttp_session
 
     async def _check_for_changes(self) -> None:
-        """Update tasks in background."""
+        """Update tasks in background, gated on the backend's update marker."""
         while True:
             try:
-                await self._update()
+                await self._poll()
             except Exception as e:
                 log.error("Failed to update tasks from backend: %s", e)
             await asyncio.sleep(5)
 
+    async def _poll(self) -> None:
+        """Re-download tasks/projects when the backend's ``last_task_update`` marker moved.
+
+        The marker is a DB-derived ``Max(updated_at)`` (pyobs-robotic-backend#84), truthful across
+        gunicorn workers, so it is a safe refresh gate. Without it the archive re-downloaded (and
+        re-compared) on every poll, and the content comparison misfired whenever runtime code
+        mutated a serialized task field (e.g. ``DynamicTarget.resolve()`` overwriting ``name``),
+        livelocking the scheduler. The content comparison in :meth:`_update` still decides whether
+        to fire ``on_tasks_changed``.
+        """
+        last_update = await self.last_update_time()
+        if self._last_marker is None or last_update > self._last_marker:
+            await self._update()
+            self._last_marker = last_update
+
     async def _update(self) -> None:
         """Fetch tasks/projects from the backend and apply them if anything changed.
 
-        Re-fetches unconditionally on every poll instead of gating on the backend's
-        ``last_task_update`` marker: that marker is computed from a per-process Django
-        ``LocMemCache`` and is unreliable across gunicorn workers, so gating on it let the
-        mastermind run stale tasks forever. Real changes are detected by comparing the downloaded
-        content against the cached copy. The comparison uses ``model_dump()`` rather than pydantic
-        ``==``, which also compares runtime attributes (e.g. ``Task._cant_run_reason`` set by
-        ``can_run()``) and would flag unchanged tasks as changed on every poll; it is keyed by ID
-        so that a stable reordering of the same items (e.g. an unordered backend queryset) is not
-        mistaken for a change.
+        Called by :meth:`_poll` after the backend marker moved (or on the first poll); applies the
+        download only when the content actually differs from the cached copy. The comparison uses
+        ``model_dump()`` rather than pydantic ``==``, which also compares runtime attributes (e.g.
+        ``Task._cant_run_reason`` set by ``can_run()``) and would flag unchanged tasks as changed
+        on every poll; it is keyed by ID so that a stable reordering of the same items (e.g. an
+        unordered backend queryset) is not mistaken for a change.
         """
         projects = await self._get_projects()
         tasks = await self._get_tasks()

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev90}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-core"
-version = "2.0.0.dev89"
+version = "2.0.0.dev90"
 description = "robotic telescope software"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"