arthexis 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

core/tasks.py

@@ -17,7 +17,7 @@ from nodes.models import NetMessage
 
 
 AUTO_UPGRADE_HEALTH_DELAY_SECONDS = 30
-AUTO_UPGRADE_HEALTH_MAX_ATTEMPTS = 3
+AUTO_UPGRADE_SKIP_LOCK_NAME = "auto_upgrade_skip_revisions.lck"
 
 
 logger = logging.getLogger(__name__)
@@ -66,6 +66,46 @@ def _append_auto_upgrade_log(base_dir: Path, message: str) -> None:
         logger.warning("Failed to append auto-upgrade log entry: %s", message)
 
 
+def _skip_lock_path(base_dir: Path) -> Path:
+    return base_dir / "locks" / AUTO_UPGRADE_SKIP_LOCK_NAME
+
+
+def _load_skipped_revisions(base_dir: Path) -> set[str]:
+    skip_file = _skip_lock_path(base_dir)
+    try:
+        return {
+            line.strip()
+            for line in skip_file.read_text().splitlines()
+            if line.strip()
+        }
+    except FileNotFoundError:
+        return set()
+    except OSError:
+        logger.warning("Failed to read auto-upgrade skip lockfile")
+        return set()
+
+
+def _add_skipped_revision(base_dir: Path, revision: str) -> None:
+    if not revision:
+        return
+
+    skip_file = _skip_lock_path(base_dir)
+    try:
+        skip_file.parent.mkdir(parents=True, exist_ok=True)
+        existing = _load_skipped_revisions(base_dir)
+        if revision in existing:
+            return
+        with skip_file.open("a", encoding="utf-8") as fh:
+            fh.write(f"{revision}\n")
+        _append_auto_upgrade_log(
+            base_dir, f"Recorded blocked revision {revision} for auto-upgrade"
+        )
+    except OSError:
+        logger.warning(
+            "Failed to update auto-upgrade skip lockfile with revision %s", revision
+        )
+
+
 def _resolve_service_url(base_dir: Path) -> str:
     """Return the local URL used to probe the Django suite."""
 
@@ -110,6 +150,23 @@ def check_github_updates() -> None:
     except Exception:
         startup = None
 
+    remote_revision = (
+        subprocess.check_output(
+            ["git", "rev-parse", f"origin/{branch}"], cwd=base_dir
+        )
+        .decode()
+        .strip()
+    )
+
+    skipped_revisions = _load_skipped_revisions(base_dir)
+    if remote_revision in skipped_revisions:
+        _append_auto_upgrade_log(
+            base_dir, f"Skipping auto-upgrade for blocked revision {remote_revision}"
+        )
+        if startup:
+            startup()
+        return
+
     upgrade_stamp = timezone.now().strftime("@ %Y%m%d %H:%M")
 
     upgrade_was_applied = False
@@ -120,19 +177,7 @@ def check_github_updates() -> None:
             .decode()
             .strip()
         )
-        remote = (
-            subprocess.check_output(
-                [
-                    "git",
-                    "rev-parse",
-                    f"origin/{branch}",
-                ],
-                cwd=base_dir,
-            )
-            .decode()
-            .strip()
-        )
-        if local == remote:
+        if local == remote_revision:
             if startup:
                 startup()
             return
@@ -254,12 +299,29 @@ def _schedule_health_check(next_attempt: int) -> None:
     )
 
 
+def _handle_failed_health_check(base_dir: Path, detail: str) -> None:
+    revision = ""
+    try:
+        revision = (
+            subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=base_dir)
+            .decode()
+            .strip()
+        )
+    except Exception:  # pragma: no cover - best effort capture
+        logger.warning("Failed to determine revision during auto-upgrade revert")
+
+    _add_skipped_revision(base_dir, revision)
+    _append_auto_upgrade_log(base_dir, "Health check failed; reverting upgrade")
+    subprocess.run(["./upgrade.sh", "--revert"], cwd=base_dir, check=True)
+
+
 @shared_task
 def verify_auto_upgrade_health(attempt: int = 1) -> bool | None:
     """Verify the upgraded suite responds successfully.
 
-    When the check fails three times in a row the upgrade is rolled back by
-    invoking ``upgrade.sh --revert``.
+    After the post-upgrade delay the site is probed once; any response other
+    than HTTP 200 triggers an automatic revert and records the failing
+    revision so future upgrade attempts skip it.
     """
 
     base_dir = Path(__file__).resolve().parent.parent
@@ -270,33 +332,29 @@ def verify_auto_upgrade_health(attempt: int = 1) -> bool | None:
     )
 
     status: int | None = None
+    detail = "succeeded"
     try:
         with urllib.request.urlopen(request, timeout=10) as response:
             status = getattr(response, "status", response.getcode())
     except urllib.error.HTTPError as exc:
         status = exc.code
+        detail = f"returned HTTP {exc.code}"
         logger.warning(
             "Auto-upgrade health check attempt %s returned HTTP %s", attempt, exc.code
         )
     except urllib.error.URLError as exc:
+        detail = f"failed with {exc}"
         logger.warning(
             "Auto-upgrade health check attempt %s failed: %s", attempt, exc
         )
     except Exception as exc:  # pragma: no cover - unexpected network error
+        detail = f"failed with {exc}"
         logger.exception(
             "Unexpected error probing suite during auto-upgrade attempt %s", attempt
         )
-        detail = f"failed with {exc}"
         _record_health_check_result(base_dir, attempt, status, detail)
-        if attempt >= AUTO_UPGRADE_HEALTH_MAX_ATTEMPTS:
-            _append_auto_upgrade_log(
-                base_dir,
-                "Health check raised unexpected error; reverting upgrade",
-            )
-            subprocess.run(["./upgrade.sh", "--revert"], cwd=base_dir, check=True)
-        else:
-            _schedule_health_check(attempt + 1)
-        return None
+        _handle_failed_health_check(base_dir, detail)
+        return False
 
     if status == 200:
         _record_health_check_result(base_dir, attempt, status, "succeeded")
@@ -307,21 +365,15 @@ def verify_auto_upgrade_health(attempt: int = 1) -> bool | None:
         )
         return True
 
-    _record_health_check_result(base_dir, attempt, status, "failed")
-
-    if attempt >= AUTO_UPGRADE_HEALTH_MAX_ATTEMPTS:
-        logger.error(
-            "Auto-upgrade health check failed after %s attempts; reverting", attempt
-        )
-        _append_auto_upgrade_log(
-            base_dir,
-            "Health check failed three times; reverting upgrade",
-        )
-        subprocess.run(["./upgrade.sh", "--revert"], cwd=base_dir, check=True)
-        return False
+    if detail == "succeeded":
+        if status is not None:
+            detail = f"returned HTTP {status}"
+        else:
+            detail = "failed with unknown status"
 
-    _schedule_health_check(attempt + 1)
-    return None
+    _record_health_check_result(base_dir, attempt, status, detail)
+    _handle_failed_health_check(base_dir, detail)
+    return False
 
 
 @shared_task

core/tests.py

@@ -770,6 +770,50 @@ class ReleaseProcessTests(TestCase):
         self.assertFalse(proc.stdout.strip())
         self.assertEqual(version_path.read_text(encoding="utf-8"), original)
 
+    @mock.patch("core.views.requests.get")
+    @mock.patch("core.views.release_utils.network_available", return_value=True)
+    @mock.patch("core.views.release_utils._git_clean", return_value=True)
+    def test_step_check_ignores_yanked_release(
+        self, git_clean, network_available, requests_get
+    ):
+        response = mock.Mock()
+        response.ok = True
+        response.json.return_value = {
+            "releases": {
+                "0.1.12": [
+                    {"filename": "pkg.whl", "yanked": True},
+                    {"filename": "pkg.tar.gz", "yanked": True},
+                ]
+            }
+        }
+        requests_get.return_value = response
+        self.release.version = "0.1.12"
+        _step_check_version(self.release, {}, Path("rel.log"))
+        requests_get.assert_called_once()
+
+    @mock.patch("core.views.requests.get")
+    @mock.patch("core.views.release_utils.network_available", return_value=True)
+    @mock.patch("core.views.release_utils._git_clean", return_value=True)
+    def test_step_check_blocks_available_release(
+        self, git_clean, network_available, requests_get
+    ):
+        response = mock.Mock()
+        response.ok = True
+        response.json.return_value = {
+            "releases": {
+                "0.1.12": [
+                    {"filename": "pkg.whl", "yanked": False},
+                    {"filename": "pkg.tar.gz"},
+                ]
+            }
+        }
+        requests_get.return_value = response
+        self.release.version = "0.1.12"
+        with self.assertRaises(Exception) as exc:
+            _step_check_version(self.release, {}, Path("rel.log"))
+        self.assertIn("already on PyPI", str(exc.exception))
+        requests_get.assert_called_once()
+
     @mock.patch("core.models.PackageRelease.dump_fixture")
     def test_save_does_not_dump_fixture(self, dump):
         self.release.pypi_url = "https://example.com"
@@ -1002,7 +1046,9 @@ class ReleaseProgressFixtureVisibilityTests(TestCase):
                 package=package, version=current_version
             )
         self.session_key = f"release_publish_{self.release.pk}"
-        self.log_name = f"{self.release.package.name}-{self.release.version}.log"
+        self.log_name = core_views._release_log_name(
+            self.release.package.name, self.release.version
+        )
         self.lock_path = Path("locks") / f"{self.session_key}.json"
         self.restart_path = Path("locks") / f"{self.session_key}.restarts"
         self.log_path = Path("logs") / self.log_name
@@ -1284,6 +1330,14 @@ class TodoDoneTests(TestCase):
         self.assertIsNotNone(todo.done_on)
         self.assertFalse(todo.is_deleted)
 
+    def test_mark_done_missing_task_refreshes(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        todo.delete()
+        resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        messages = [m.message for m in get_messages(resp.wsgi_request)]
+        self.assertFalse(messages)
+
     def test_mark_done_condition_failure_shows_message(self):
         todo = Todo.objects.create(
             request="Task",
@@ -1369,6 +1423,13 @@ class TodoFocusViewTests(TestCase):
         change_url = reverse("admin:core_todo_change", args=[todo.pk])
         self.assertContains(resp, f'src="{change_url}"')
 
+    def test_focus_view_includes_open_target_button(self):
+        todo = Todo.objects.create(request="Task", url="/docs/")
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        self.assertContains(resp, 'class="todo-button todo-button-open"')
+        self.assertContains(resp, 'target="_blank"')
+        self.assertContains(resp, 'href="/docs/"')
+
     def test_focus_view_sanitizes_loopback_absolute_url(self):
         todo = Todo.objects.create(
             request="Task",
@@ -1402,6 +1463,19 @@ class TodoFocusViewTests(TestCase):
         change_url = reverse("admin:core_todo_change", args=[todo.pk])
         self.assertContains(resp, f'src="{change_url}"')
 
+    def test_focus_view_parses_auth_directives(self):
+        todo = Todo.objects.create(
+            request="Task",
+            url="/docs/?section=chart&_todo_auth=logout&_todo_auth=user:demo&_todo_auth=perm:core.view_user&_todo_auth=extra",
+        )
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        self.assertContains(resp, 'src="/docs/?section=chart"')
+        self.assertContains(resp, 'href="/docs/?section=chart"')
+        self.assertContains(resp, "logged out")
+        self.assertContains(resp, "Sign in using: demo")
+        self.assertContains(resp, "Required permissions: core.view_user")
+        self.assertContains(resp, "Additional authentication notes: extra")
+
     def test_focus_view_redirects_if_todo_completed(self):
         todo = Todo.objects.create(request="Task")
         todo.done_on = timezone.now()

core/views.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import shutil
 from datetime import timedelta
 
@@ -8,7 +9,7 @@ from django.contrib.admin.views.decorators import staff_member_required
 from django.contrib.auth import authenticate, login
 from django.contrib import messages
 from django.contrib.sites.models import Site
-from django.http import Http404, JsonResponse
+from django.http import Http404, JsonResponse, HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render, resolve_url
 from django.utils import timezone
 from django.utils.text import slugify
@@ -18,13 +19,18 @@ from django.views.decorators.csrf import csrf_exempt
 from django.views.decorators.http import require_GET, require_POST
 from django.utils.http import url_has_allowed_host_and_scheme
 from pathlib import Path
-from urllib.parse import urlsplit, urlunsplit
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 import errno
 import subprocess
 
+from django.template.loader import get_template
+from django.test import signals
+
 from utils import revision
 from utils.api import api_login_required
 
+logger = logging.getLogger(__name__)
+
 from .models import Product, EnergyAccount, PackageRelease, Todo
 from .models import RFID
 
@@ -40,10 +46,17 @@ def odoo_products(request):
         products = profile.execute(
             "product.product",
             "search_read",
-            [],
+            [[]],
             {"fields": ["name"], "limit": 50},
         )
     except Exception:
+        logger.exception(
+            "Failed to fetch Odoo products via API for user %s (profile_id=%s, host=%s, database=%s)",
+            getattr(request.user, "pk", None),
+            getattr(profile, "pk", None),
+            getattr(profile, "host", None),
+            getattr(profile, "database", None),
+        )
         return JsonResponse({"detail": "Unable to fetch products"}, status=502)
     items = [{"id": p.get("id"), "name": p.get("name", "")} for p in products]
     return JsonResponse(items, safe=False)
@@ -77,6 +90,10 @@ def _append_log(path: Path, message: str) -> None:
         fh.write(message + "\n")
 
 
+def _release_log_name(package_name: str, version: str) -> str:
+    return f"pr.{package_name}.v{version}.log"
+
+
 def _clean_repo() -> None:
     """Return the git repository to a clean state."""
     subprocess.run(["git", "reset", "--hard"], check=False)
@@ -357,7 +374,7 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
 
 def _step_check_version(release, ctx, log_path: Path) -> None:
     from . import release as release_utils
-    from packaging.version import Version
+    from packaging.version import InvalidVersion, Version
 
     if not release_utils._git_clean():
         proc = subprocess.run(
@@ -417,8 +434,33 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
     if release_utils.network_available():
         try:
             resp = requests.get(f"https://pypi.org/pypi/{release.package.name}/json")
-            if resp.ok and release.version in resp.json().get("releases", {}):
-                raise Exception(f"Version {release.version} already on PyPI")
+            if resp.ok:
+                data = resp.json()
+                releases = data.get("releases", {})
+                try:
+                    target_version = Version(release.version)
+                except InvalidVersion:
+                    target_version = None
+
+                for candidate, files in releases.items():
+                    same_version = candidate == release.version
+                    if target_version is not None and not same_version:
+                        try:
+                            same_version = Version(candidate) == target_version
+                        except InvalidVersion:
+                            same_version = False
+                    if not same_version:
+                        continue
+
+                    has_available_files = any(
+                        isinstance(file_data, dict)
+                        and not file_data.get("yanked", False)
+                        for file_data in files or []
+                    )
+                    if has_available_files:
+                        raise Exception(
+                            f"Version {release.version} already on PyPI"
+                        )
         except Exception as exc:
             # network errors should be logged but not crash
             if "already on PyPI" in str(exc):
@@ -574,9 +616,14 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
     except Exception:
         _clean_repo()
         raise
-    release_name = f"{release.package.name}-{release.version}"
-    new_log = log_path.with_name(f"{release_name}.log")
-    log_path.rename(new_log)
+    target_name = _release_log_name(release.package.name, release.version)
+    new_log = log_path.with_name(target_name)
+    if log_path != new_log:
+        if new_log.exists():
+            new_log.unlink()
+        log_path.rename(new_log)
+    else:
+        new_log = log_path
     ctx["log"] = new_log.name
     _append_log(new_log, "Build complete")
 
@@ -855,9 +902,8 @@ def release_progress(request, pk: int, action: str):
             if restart_path.exists():
                 restart_path.unlink()
             log_dir = Path("logs")
-            for log_file in log_dir.glob(
-                f"{release.package.name}-{previous_version}*.log"
-            ):
+            pattern = f"pr.{release.package.name}.v{previous_version}*.log"
+            for log_file in log_dir.glob(pattern):
                 log_file.unlink()
         if not release.is_current:
             raise Http404("Release is not current")
@@ -879,7 +925,8 @@ def release_progress(request, pk: int, action: str):
         if lock_path.exists():
             lock_path.unlink()
         log_dir = Path("logs")
-        for f in log_dir.glob(f"{release.package.name}-{release.version}*.log"):
+        pattern = f"pr.{release.package.name}.v{release.version}*.log"
+        for f in log_dir.glob(pattern):
             f.unlink()
         return redirect(request.path)
     ctx = request.session.get(session_key)
@@ -954,8 +1001,7 @@ def release_progress(request, pk: int, action: str):
     else:
         ctx.pop("todos", None)
 
-    identifier = f"{release.package.name}-{release.version}"
-    log_name = f"{identifier}.log"
+    log_name = _release_log_name(release.package.name, release.version)
     if ctx.get("log") != log_name:
         ctx = {
             "step": 0,
@@ -1161,16 +1207,95 @@ def release_progress(request, pk: int, action: str):
     else:
         lock_path.parent.mkdir(parents=True, exist_ok=True)
         lock_path.write_text(json.dumps(ctx), encoding="utf-8")
-    return render(request, "core/release_progress.html", context)
+    template = get_template("core/release_progress.html")
+    content = template.render(context, request)
+    signals.template_rendered.send(
+        sender=template.__class__,
+        template=template,
+        context=context,
+        using=getattr(getattr(template, "engine", None), "name", None),
+    )
+    response = HttpResponse(content)
+    response.context = context
+    response.templates = [template]
+    return response
+
+
+def _dedupe_preserve_order(values):
+    seen = set()
+    result = []
+    for value in values:
+        if value in seen:
+            continue
+        seen.add(value)
+        result.append(value)
+    return result
+
+
+def _parse_todo_auth_directives(query: str):
+    directives = {
+        "require_logout": False,
+        "users": [],
+        "permissions": [],
+        "notes": [],
+    }
+    if not query:
+        return "", directives
+
+    remaining = []
+    for key, value in parse_qsl(query, keep_blank_values=True):
+        if key != "_todo_auth":
+            remaining.append((key, value))
+            continue
+        token = (value or "").strip()
+        if not token:
+            continue
+        kind, _, payload = token.partition(":")
+        kind = kind.strip().lower()
+        payload = payload.strip()
+        if kind in {"logout", "anonymous", "anon"}:
+            directives["require_logout"] = True
+        elif kind in {"user", "username"} and payload:
+            directives["users"].append(payload)
+        elif kind in {"perm", "permission"} and payload:
+            directives["permissions"].append(payload)
+        else:
+            directives["notes"].append(token)
+
+    sanitized_query = urlencode(remaining, doseq=True)
+    return sanitized_query, directives
 
 
-def _todo_iframe_url(request, todo: Todo) -> str:
-    """Return a safe iframe URL for ``todo`` scoped to the current host."""
+def _todo_iframe_url(request, todo: Todo):
+    """Return a safe iframe URL and auth context for ``todo``."""
 
     fallback = reverse("admin:core_todo_change", args=[todo.pk])
     raw_url = (todo.url or "").strip()
+
+    auth_context = {
+        "require_logout": False,
+        "users": [],
+        "permissions": [],
+        "notes": [],
+    }
+
+    def _final_context(target_url: str):
+        return {
+            "target_url": target_url or fallback,
+            "require_logout": auth_context["require_logout"],
+            "users": _dedupe_preserve_order(auth_context["users"]),
+            "permissions": _dedupe_preserve_order(auth_context["permissions"]),
+            "notes": _dedupe_preserve_order(auth_context["notes"]),
+            "has_requirements": bool(
+                auth_context["require_logout"]
+                or auth_context["users"]
+                or auth_context["permissions"]
+                or auth_context["notes"]
+            ),
+        }
+
     if not raw_url:
-        return fallback
+        return fallback, _final_context(fallback)
 
     focus_path = reverse("todo-focus", args=[todo.pk])
     focus_norm = focus_path.strip("/").lower()
@@ -1186,14 +1311,31 @@ def _todo_iframe_url(request, todo: Todo) -> str:
         return normalized == focus_norm if normalized else False
 
     if _is_focus_target(raw_url):
-        return fallback
+        return fallback, _final_context(fallback)
 
     parsed = urlsplit(raw_url)
+
+    def _merge_directives(parsed_result):
+        sanitized_query, directives = _parse_todo_auth_directives(parsed_result.query)
+        if directives["require_logout"]:
+            auth_context["require_logout"] = True
+        auth_context["users"].extend(directives["users"])
+        auth_context["permissions"].extend(directives["permissions"])
+        auth_context["notes"].extend(directives["notes"])
+        return parsed_result._replace(query=sanitized_query)
+
     if not parsed.scheme and not parsed.netloc:
-        return fallback if _is_focus_target(parsed.path) else raw_url
+        sanitized = _merge_directives(parsed)
+        path = sanitized.path or "/"
+        if not path.startswith("/"):
+            path = f"/{path}"
+        relative_url = urlunsplit(("", "", path, sanitized.query, sanitized.fragment))
+        if _is_focus_target(relative_url):
+            return fallback, _final_context(fallback)
+        return relative_url or fallback, _final_context(relative_url)
 
     if parsed.scheme and parsed.scheme.lower() not in {"http", "https"}:
-        return fallback
+        return fallback, _final_context(fallback)
 
     request_host = request.get_host().strip().lower()
     host_without_port = request_host.split(":", 1)[0]
@@ -1227,15 +1369,16 @@ def _todo_iframe_url(request, todo: Todo) -> str:
     hostname = (parsed.hostname or "").strip().lower()
     netloc = parsed.netloc.strip().lower()
     if hostname in allowed_hosts or netloc in allowed_hosts:
-        path = parsed.path or "/"
+        sanitized = _merge_directives(parsed)
+        path = sanitized.path or "/"
         if not path.startswith("/"):
             path = f"/{path}"
-        relative_url = urlunsplit(("", "", path, parsed.query, parsed.fragment))
+        relative_url = urlunsplit(("", "", path, sanitized.query, sanitized.fragment))
         if _is_focus_target(relative_url):
-            return fallback
-        return relative_url or fallback
+            return fallback, _final_context(fallback)
+        return relative_url or fallback, _final_context(relative_url)
 
-    return fallback
+    return fallback, _final_context(fallback)
 
 
 @staff_member_required
@@ -1244,10 +1387,13 @@ def todo_focus(request, pk: int):
     if todo.done_on:
         return redirect(_get_return_url(request))
 
-    iframe_url = _todo_iframe_url(request, todo)
+    iframe_url, focus_auth = _todo_iframe_url(request, todo)
+    focus_target_url = focus_auth.get("target_url", iframe_url) if focus_auth else iframe_url
     context = {
         "todo": todo,
         "iframe_url": iframe_url,
+        "focus_target_url": focus_target_url,
+        "focus_auth": focus_auth,
         "next_url": _get_return_url(request),
         "done_url": reverse("todo-done", args=[todo.pk]),
     }
@@ -1257,8 +1403,11 @@ def todo_focus(request, pk: int):
 @staff_member_required
 @require_POST
 def todo_done(request, pk: int):
-    todo = get_object_or_404(Todo, pk=pk, is_deleted=False, done_on__isnull=True)
     redirect_to = _get_return_url(request)
+    try:
+        todo = Todo.objects.get(pk=pk, is_deleted=False, done_on__isnull=True)
+    except Todo.DoesNotExist:
+        return redirect(redirect_to)
     result = todo.check_on_done_condition()
     if not result.passed:
         messages.error(request, _format_condition_failure(todo, result))