diracx 0.0.4__tar.gz → 0.0.5__tar.gz

diracx-0.0.5/.github/workflows/update_chart_version.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+"""Script to update chart versions based on DiracX releases."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+import requests
+import yaml
+
+
+def parse_version(version_str: str) -> tuple[int, int, int, str | None]:
+    """Parse a semantic version string into components.
+
+    Args:
+        version_str: Version string like "1.0.0-alpha.1"
+
+    Returns:
+        Tuple of (major, minor, patch, pre_release_suffix)
+
+    """
+    # Remove leading 'v' if present
+    version_str = version_str.lstrip("v")
+
+    # Pattern for semver with optional pre-release
+    pattern = r"^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$"
+    match = re.match(pattern, version_str)
+
+    if not match:
+        raise ValueError(f"Invalid version format: {version_str}")
+
+    major, minor, patch, pre_release = match.groups()
+    return int(major), int(minor), int(patch), pre_release
+
+
+def bump_version(current_version: str) -> str:
+    """Bump a version automatically - alpha if present, else patch.
+
+    Args:
+        current_version: Current version string
+
+    Returns:
+        New version string
+
+    """
+    major, minor, patch, pre_release = parse_version(current_version)
+
+    if pre_release and pre_release.startswith("alpha."):
+        # Increment alpha number
+        alpha_match = re.match(r"alpha\.(\d+)", pre_release)
+        if alpha_match:
+            alpha_num = int(alpha_match.group(1)) + 1
+            return f"{major}.{minor}.{patch}-alpha.{alpha_num}"
+        else:
+            # Invalid alpha format, start with alpha.1
+            return f"{major}.{minor}.{patch}-alpha.1"
+    else:
+        # No alpha suffix, bump patch version
+        return f"{major}.{minor}.{patch + 1}"
+
+
+def update_chart_yaml(
+    chart_path: Path,
+    app_version: str,
+    new_chart_version: str,
+    dependency_name: str | None = None,
+    dependency_version: str | None = None,
+) -> None:
+    """Update Chart.yaml with new versions.
+
+    Args:
+        chart_path: Path to Chart.yaml
+        app_version: New application version
+        new_chart_version: New chart version
+        dependency_name: Optional name of dependency to update
+        dependency_version: Optional version for the dependency
+
+    """
+    content = chart_path.read_text()
+
+    # Update appVersion
+    content = re.sub(
+        r"^appVersion:\s*.*$",
+        f"appVersion: {app_version}",
+        content,
+        flags=re.MULTILINE,
+    )
+
+    # Update version
+    content = re.sub(
+        r"^version:\s*.*$",
+        f'version: "{new_chart_version}"',
+        content,
+        flags=re.MULTILINE,
+    )
+
+    # Update dependency version if specified
+    if dependency_name and dependency_version:
+        # Use YAML to properly update the dependency
+        chart_data = yaml.safe_load(content)
+        if "dependencies" in chart_data:
+            for dep in chart_data["dependencies"]:
+                if dep.get("name") == dependency_name:
+                    dep["version"] = dependency_version
+                    break
+        # Use regex for dependency update to preserve formatting
+        # Match the dependency block and update the version
+        name_pat = re.escape(dependency_name)
+        dep_pattern = (
+            rf'(- name:\s*{name_pat}\s*\n(?:.*\n)*?\s*version:\s*)("[^"]*"|[^\n]*)'
+        )
+        content = re.sub(dep_pattern, rf'\g<1>"{dependency_version}"', content)
+
+    chart_path.write_text(content)
+
+
+def update_values_yaml(
+    values_path: Path, app_version: str, image_tag_path: str
+) -> None:
+    """Update values.yaml with new image tag.
+
+    Args:
+        values_path: Path to values.yaml
+        app_version: New application version to set as image tag
+        image_tag_path: Dot-separated path to the image tag field (e.g., "global.images.tag")
+
+    """
+    content = values_path.read_text()
+    data = yaml.safe_load(content)
+
+    # Navigate to the parent of the tag field and update it
+    path_parts = image_tag_path.split(".")
+    current = data
+    for part in path_parts[:-1]:
+        if part not in current:
+            print(f"Warning: Path '{part}' not found in values.yaml")
+            return
+        current = current[part]
+
+    tag_key = path_parts[-1]
+    if tag_key not in current:
+        print(f"Warning: Key '{tag_key}' not found at path in values.yaml")
+        return
+
+    old_value = current[tag_key]
+    current[tag_key] = app_version
+
+    # Use regex to preserve formatting - find and replace the specific value
+    # Build a regex pattern that matches the nested structure
+    # This is more reliable than re-serializing the entire YAML
+    def build_yaml_path_pattern(parts: list[str], value: str) -> tuple[str, str]:
+        """Build a regex pattern to find and replace a nested YAML value."""
+        # For simple cases, we use a pattern that finds the key and its value
+        # at the appropriate nesting level
+        key = parts[-1]
+        # Match the key followed by its value, being careful about indentation
+        pattern = rf"({re.escape(key)}:\s*)({re.escape(str(value))})"
+        replacement = rf"\g<1>{app_version}"
+        return pattern, replacement
+
+    pattern, replacement = build_yaml_path_pattern(path_parts, str(old_value))
+    new_content = re.sub(pattern, replacement, content, count=1)
+
+    if new_content == content:
+        # Fallback: if regex didn't match, dump the modified YAML
+        print("Warning: Using YAML dump fallback for values.yaml update")
+        new_content = yaml.dump(data, default_flow_style=False, sort_keys=False)
+
+    values_path.write_text(new_content)
+
+
+def lookup_dependency_chart_version(
+    index_url: str, dependency_name: str, app_version: str
+) -> str | None:
+    """Look up the chart version for a dependency given its app version.
+
+    Args:
+        index_url: URL to the Helm chart index.yaml
+        dependency_name: Name of the dependency chart
+        app_version: Application version to match
+
+    Returns:
+        The chart version that matches the app version, or None if not found
+
+    """
+    print(f"Fetching chart index from {index_url}...")
+    response = requests.get(index_url, timeout=30)
+    response.raise_for_status()
+
+    index_data = yaml.safe_load(response.text)
+
+    if "entries" not in index_data:
+        print("Error: No entries found in chart index")
+        return None
+
+    if dependency_name not in index_data["entries"]:
+        print(f"Error: Dependency '{dependency_name}' not found in chart index")
+        return None
+
+    # Normalize the app version for comparison (remove 'v' prefix if present)
+    normalized_app_version = app_version.lstrip("v")
+
+    # Find the chart version with matching appVersion
+    for entry in index_data["entries"][dependency_name]:
+        entry_app_version = str(entry.get("appVersion", "")).lstrip("v")
+        if entry_app_version == normalized_app_version:
+            chart_version = entry.get("version")
+            print(
+                f"Found {dependency_name} chart version {chart_version} "
+                f"for app version {app_version}"
+            )
+            return chart_version
+
+    print(
+        f"Warning: No chart found for {dependency_name} with app version {app_version}"
+    )
+    return None
+
+
+def main() -> None:
+    """Main function."""
+    parser = argparse.ArgumentParser(
+        description="Update chart versions for DiracX release"
+    )
+    parser.add_argument(
+        "--charts-dir", type=Path, default=".", help="Path to charts directory"
+    )
+    parser.add_argument(
+        "--chart-subdir",
+        type=str,
+        default="diracx",
+        help="Subdirectory containing chart files (use '.' for root)",
+    )
+    parser.add_argument(
+        "--app-version",
+        required=True,
+        help="Application version (e.g., v0.0.1a49)",
+    )
+    parser.add_argument(
+        "--image-tag-path",
+        type=str,
+        default="global.images.tag",
+        help="Dot-separated YAML path to image tag in values.yaml",
+    )
+    parser.add_argument(
+        "--update-dependency",
+        type=str,
+        help="Name of dependency to update in Chart.yaml",
+    )
+    parser.add_argument(
+        "--dependency-app-version",
+        type=str,
+        help="App version to match for the dependency",
+    )
+    parser.add_argument(
+        "--dependency-chart-index",
+        type=str,
+        default="https://charts.diracgrid.org/index.yaml",
+        help="URL to the dependency's chart index.yaml",
+    )
+
+    args = parser.parse_args()
+
+    # Determine chart subdirectory
+    if args.chart_subdir == ".":
+        chart_subdir = args.charts_dir
+    else:
+        chart_subdir = args.charts_dir / args.chart_subdir
+
+    # Define paths
+    chart_yaml = chart_subdir / "Chart.yaml"
+    values_yaml = chart_subdir / "values.yaml"
+
+    if not chart_yaml.exists():
+        print(f"Error: Chart.yaml not found at {chart_yaml}")
+        sys.exit(1)
+
+    if not values_yaml.exists():
+        print(f"Error: values.yaml not found at {values_yaml}")
+        sys.exit(1)
+
+    # Get current chart version using YAML parser to handle comments correctly
+    chart_content = chart_yaml.read_text()
+    chart_data = yaml.safe_load(chart_content)
+    version_match = chart_data.get("version")
+
+    if not version_match:
+        print("Error: Could not find version in Chart.yaml")
+        sys.exit(1)
+
+    current_chart_version = str(version_match)
+    print(f"Current chart version: {current_chart_version}")
+
+    # Calculate new chart version (alpha if present, else patch)
+    new_chart_version = bump_version(current_chart_version)
+    print(f"New chart version: {new_chart_version}")
+
+    # Look up dependency chart version if needed
+    dependency_version = None
+    if args.update_dependency:
+        if not args.dependency_app_version:
+            parser.error("--update-dependency requires --dependency-app-version")
+        dependency_version = lookup_dependency_chart_version(
+            args.dependency_chart_index,
+            args.update_dependency,
+            args.dependency_app_version,
+        )
+        if not dependency_version:
+            print(
+                f"Error: Could not find chart version for {args.update_dependency} "
+                f"with app version {args.dependency_app_version}"
+            )
+            sys.exit(1)
+
+    # Update files
+    print("Updating Chart.yaml...")
+    update_chart_yaml(
+        chart_yaml,
+        args.app_version,
+        new_chart_version,
+        args.update_dependency,
+        dependency_version,
+    )
+
+    print("Updating values.yaml...")
+    update_values_yaml(values_yaml, args.app_version, args.image_tag_path)
+
+    print(f"Successfully updated charts for app version {args.app_version}")
+    print(f"Chart version: {current_chart_version} -> {new_chart_version}")
+    if dependency_version:
+        print(f"Dependency {args.update_dependency} version: {dependency_version}")
+
+
+if __name__ == "__main__":
+    main()

{diracx-0.0.4 → diracx-0.0.5}/.pre-commit-config.yaml

@@ -30,7 +30,7 @@ repos:
       - id: check-added-large-files
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.14.11'
+    rev: 'v0.14.13'
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]

{diracx-0.0.4 → diracx-0.0.5}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.0.5](https://github.com/DIRACGrid/diracx/compare/v0.0.4...v0.0.5) (2026-01-20)
+
+
+### Features
+
+* add logging for error conditions and edge cases ([#734](https://github.com/DIRACGrid/diracx/issues/734)) ([2c8b5c6](https://github.com/DIRACGrid/diracx/commit/2c8b5c682f17270e341deaf23cd4a7b4b7c4dd0a))
+* extend update_chart_version.py for downstream charts ([#731](https://github.com/DIRACGrid/diracx/issues/731)) ([b1a293b](https://github.com/DIRACGrid/diracx/commit/b1a293b01ad062d162afdfb5377a76c95eb09913))
+
+
+### Bug Fixes
+
+* use YAML parser for chart version to handle comments ([9516971](https://github.com/DIRACGrid/diracx/commit/95169716206bb476f450fff8fd228ada649fef5b))
+
+
+### Miscellaneous Chores
+
+* release 0.0.5 ([c0f166b](https://github.com/DIRACGrid/diracx/commit/c0f166bf29e1ed0ac2b5aa89ebb39ac60cfe23d3))
+
 ## [0.0.4](https://github.com/DIRACGrid/diracx/compare/v0.0.3...v0.0.4) (2026-01-19)
 
 

{diracx-0.0.4 → diracx-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diracx
-Version: 0.0.4
+Version: 0.0.5
 Summary: Client installation for users of DiracX installations
 License: GPL-3.0-only
 License-File: LICENSE

{diracx-0.0.4 → diracx-0.0.5}/diracx-db/src/diracx/db/sql/auth/db.py

@@ -178,6 +178,10 @@ class AuthDB(BaseSQLDB):
                 await self.conn.execute(stmt)
 
             except IntegrityError:
+                logger.warning(
+                    "Device flow code collision detected, retrying (user_code=%s)",
+                    user_code,
+                )
                 continue
 
             return user_code, device_code

{diracx-0.0.4 → diracx-0.0.5}/diracx-db/src/diracx/db/sql/utils/base.py

@@ -211,6 +211,12 @@ class BaseSQLDB(metaclass=ABCMeta):
         try:
             self._conn.set(await self.engine.connect().__aenter__())
         except Exception as e:
+            logger.warning(
+                "Database connection failed for %s: %s",
+                self.__class__.__name__,
+                e,
+                exc_info=True,
+            )
             raise SQLDBUnavailableError(
                 f"Cannot connect to {self.__class__.__name__}"
             ) from e

{diracx-0.0.4 → diracx-0.0.5}/diracx-routers/src/diracx/routers/auth/authorize_code_flow.py

@@ -5,6 +5,7 @@ See docs/admin/explanations/authentication.md
 
 from __future__ import annotations
 
+import logging
 from typing import Literal
 
 from fastapi import (
@@ -30,6 +31,8 @@ from ..dependencies import (
 )
 from ..fastapi_classes import DiracxRouter
 
+logger = logging.getLogger(__name__)
+
 router = DiracxRouter(require_auth=False)
 
 
@@ -115,15 +118,18 @@ async def complete_authorization_flow(
             settings=settings,
         )
     except AuthorizationError as e:
+        logger.warning("Authorization flow failed with invalid state: %s", e)
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid state"
         ) from e
     except IAMServerError as e:
+        logger.warning("IAM server error during authorization flow: %s", e)
         raise HTTPException(
             status_code=status.HTTP_502_BAD_GATEWAY,
             detail="Failed to contact IAM server",
         ) from e
     except IAMClientError as e:
+        logger.warning("IAM client error during authorization flow: %s", e)
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid code"
         ) from e

{diracx-0.0.4 → diracx-0.0.5}/diracx-routers/src/diracx/routers/auth/device_flow.py

@@ -5,6 +5,8 @@ See docs/admin/explanations/authentication.md
 
 from __future__ import annotations
 
+import logging
+
 from fastapi import (
     HTTPException,
     Request,
@@ -32,6 +34,8 @@ from ..dependencies import (
 )
 from ..fastapi_classes import DiracxRouter
 
+logger = logging.getLogger(__name__)
+
 router = DiracxRouter(require_auth=False)
 
 
@@ -136,11 +140,13 @@ async def finish_device_flow(
             settings,
         )
     except IAMServerError as e:
+        logger.warning("IAM server error during device flow completion: %s", e)
         raise HTTPException(
             status_code=status.HTTP_502_BAD_GATEWAY,
             detail=e.args[0],
         ) from e
     except IAMClientError as e:
+        logger.warning("IAM client error during device flow completion: %s", e)
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail=e.args[0],

{diracx-0.0.4 → diracx-0.0.5}/diracx-routers/src/diracx/routers/auth/management.py

@@ -82,7 +82,11 @@ async def revoke_refresh_token_by_refresh_token(
             auth_db, None, token, token_type_hint, client_id, settings
         )
     except (DecodeError, KeyError):
-        logger.warning("Someone tried to revoke its token but failed.")
+        logger.warning(
+            "Token revocation failed: invalid token format (client_id=%s)",
+            client_id,
+            exc_info=True,
+        )
     except ValueError as e:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,

{diracx-0.0.4 → diracx-0.0.5}/diracx-routers/src/diracx/routers/configuration.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from datetime import datetime, timezone
 from typing import Annotated
 
@@ -14,6 +15,8 @@ from .access_policies import open_access
 from .dependencies import Config
 from .fastapi_classes import DiracxRouter
 
+logger = logging.getLogger(__name__)
+
 LAST_MODIFIED_FORMAT = "%a, %d %b %Y %H:%M:%S GMT"
 
 router = DiracxRouter()
@@ -52,7 +55,9 @@ async def serve_config(
                 if_modified_since, LAST_MODIFIED_FORMAT
             ).astimezone(timezone.utc)
         except ValueError:
-            pass
+            logger.debug(
+                "Failed to parse If-Modified-Since header: %s", if_modified_since
+            )
         else:
             if not_before > config._modified:
                 raise HTTPException(

{diracx-0.0.4 → diracx-0.0.5}/diracx-routers/src/diracx/routers/factory.py

@@ -76,7 +76,7 @@ def configure_logger():
         uvicorn_access_logger.handlers[0].setFormatter(AccessFormatter(new_format))
     # There may not be any handler defined, like in the CI
     except IndexError:
-        pass
+        logger.debug("No handlers found for uvicorn.access logger (expected in CI)")
 
     uvicorn_logger = logging.getLogger("uvicorn")
     try:
@@ -85,7 +85,7 @@ def configure_logger():
         uvicorn_logger.handlers[0].setFormatter(DefaultFormatter(new_format))
     # There may not be any handler defined, like in the CI
     except IndexError:
-        pass
+        logger.debug("No handlers found for uvicorn logger (expected in CI)")
 
 
 # Rules:
@@ -404,6 +404,12 @@ def http_response_handler(request: Request, exc: DiracHttpResponseError) -> Resp
 
 
 def route_unavailable_error_hander(request: Request, exc: DBUnavailableError):
+    logger.warning(
+        "503 Service Unavailable: %s (path=%s)",
+        exc,
+        request.url.path,
+        exc_info=True,
+    )
     return JSONResponse(
         status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
         headers={"Retry-After": "10"},
@@ -510,9 +516,13 @@ class ClientMinVersionCheckMiddleware(BaseHTTPMiddleware):
                 status_code=exc.status_code,
                 content={"detail": exc.detail},
             )
-        # If the version is not given
-        except Exception:  # noqa: S110
-            pass
+        # If the version is not given or cannot be parsed
+        except Exception:
+            logger.debug(
+                "Failed to check client version header: %s",
+                client_version,
+                exc_info=True,
+            )
 
         response = await call_next(request)
         return response

{diracx-0.0.4 → diracx-0.0.5}/diracx-routers/src/diracx/routers/health/probes.py

@@ -4,12 +4,16 @@ from __future__ import annotations
 
 __all__ = ["router"]
 
+import logging
+
 from fastapi import HTTPException
 from starlette.responses import JSONResponse
 
 from ..dependencies import AuthDB, Config
 from ..fastapi_classes import DiracxRouter
 
+logger = logging.getLogger(__name__)
+
 router = DiracxRouter(require_auth=False)
 
 
@@ -35,6 +39,7 @@ async def ready(config: Config, auth_db: AuthDB):
     try:
         await auth_db.ping()
     except Exception as e:
+        logger.warning("Ready probe failed: AuthDB ping failed", exc_info=True)
         raise HTTPException(status_code=503, detail="AuthDB ping failed") from e
     return JSONResponse(content={"status": "ready"})
 
@@ -50,5 +55,6 @@ async def startup(config: Config, auth_db: AuthDB):
     try:
         await auth_db.ping()
     except Exception as e:
+        logger.warning("Startup probe failed: AuthDB ping failed", exc_info=True)
         raise HTTPException(status_code=503, detail="AuthDB ping failed") from e
     return JSONResponse(content={"status": "startup complete"})

{diracx-0.0.4 → diracx-0.0.5}/diracx-routers/src/diracx/routers/utils/users.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import re
 import uuid as std_uuid
 from typing import Annotated, Any
@@ -17,6 +18,8 @@ from diracx.core.properties import SecurityProperty
 from diracx.logic.auth.utils import read_token
 from diracx.routers.dependencies import AuthSettings
 
+logger = logging.getLogger(__name__)
+
 # auto_error=False is used to avoid raising the wrong exception when the token is missing
 # The error is handled in the verify_dirac_access_token function
 # More info:
@@ -99,6 +102,7 @@ async def verify_dirac_access_token(
             ),
         )
     except JoseError as e:
+        logger.warning("Token validation failed: %s", e)
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Invalid JWT",