orchestrator-core 4.3.0rc3__tar.gz → 4.4.0__tar.gz

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.3.0rc3
+Version: 4.4.0
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14
@@ -32,6 +32,7 @@ Classifier: Typing :: Typed
 License-File: LICENSE
 Requires-Dist: alembic==1.16.1
 Requires-Dist: anyio>=3.7.0
+Requires-Dist: apscheduler>=3.11.0
 Requires-Dist: click==8.*
 Requires-Dist: deepmerge==2.0
 Requires-Dist: deprecated>=1.2.18
@@ -52,7 +53,6 @@ Requires-Dist: python-dateutil==2.8.2
 Requires-Dist: python-rapidjson>=1.18,<1.21
 Requires-Dist: pytz==2025.2
 Requires-Dist: redis==5.1.1
-Requires-Dist: schedule==1.1.0
 Requires-Dist: semver==3.0.4
 Requires-Dist: sentry-sdk[fastapi]~=2.29.1
 Requires-Dist: sqlalchemy==2.0.41

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "4.3.0rc3"
+__version__ = "4.4.0"
 
 from orchestrator.app import OrchestratorCore
 from orchestrator.settings import app_settings

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/api/api_v1/endpoints/processes.py

@@ -25,7 +25,7 @@ from fastapi.param_functions import Body, Depends, Header
 from fastapi.routing import APIRouter
 from fastapi.websockets import WebSocket
 from fastapi_etag.dependency import CacheHit
-from more_itertools import chunked, last
+from more_itertools import chunked, first, last
 from sentry_sdk.tracing import trace
 from sqlalchemy import CompoundSelect, Select, select
 from sqlalchemy.orm import defer, joinedload
@@ -88,11 +88,17 @@ def check_global_lock() -> None:
         )
 
 
-def get_current_steps(pstat: ProcessStat) -> StepList:
-    """Extract past and current steps from the ProcessStat."""
-    remaining_steps = pstat.log
+def get_steps_to_evaluate_for_rbac(pstat: ProcessStat) -> StepList:
+    """Extract all steps from the ProcessStat for a process that should be evaluated for a RBAC callback.
+
+    For a suspended process this includes all previously completed steps as well as the current step.
+    For a completed process this includes all steps.
+    """
+    if not (remaining_steps := pstat.log):
+        return pstat.workflow.steps
+
     past_steps = pstat.workflow.steps[: -len(remaining_steps)]
-    return StepList(past_steps + [pstat.log[0]])
+    return StepList(past_steps >> first(remaining_steps))
 
 
 def get_auth_callbacks(steps: StepList, workflow: Workflow) -> tuple[Authorizer | None, Authorizer | None]:
@@ -200,7 +206,7 @@ def resume_process_endpoint(
         raise_status(HTTPStatus.CONFLICT, f"Resuming a {process.last_status.lower()} workflow is not possible")
 
     pstat = load_process(process)
-    auth_resume, auth_retry = get_auth_callbacks(get_current_steps(pstat), pstat.workflow)
+    auth_resume, auth_retry = get_auth_callbacks(get_steps_to_evaluate_for_rbac(pstat), pstat.workflow)
     if process.last_status == ProcessStatus.SUSPENDED:
         if auth_resume is not None and not auth_resume(user_model):
             raise_status(HTTPStatus.FORBIDDEN, "User is not authorized to resume step")

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/api/api_v1/endpoints/subscriptions.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 
 """Module that implements subscription related API endpoints."""
+
 from http import HTTPStatus
 from typing import Any
 from uuid import UUID

orchestrator_core-4.4.0/orchestrator/cli/scheduler.py

@@ -0,0 +1,68 @@
+# Copyright 2019-2020 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import logging
+import time
+
+import typer
+
+from orchestrator.schedules.scheduler import (
+    get_paused_scheduler,
+)
+
+log = logging.getLogger(__name__)
+
+app: typer.Typer = typer.Typer()
+
+
+@app.command()
+def run() -> None:
+    """Start scheduler and loop eternally to keep thread alive."""
+    with get_paused_scheduler() as scheduler:
+        scheduler.resume()
+
+        while True:
+            time.sleep(1)
+
+
+@app.command()
+def show_schedule() -> None:
+    """Show the currently configured schedule.
+
+    in cli underscore is replaced by a dash `show-schedule`
+    """
+    with get_paused_scheduler() as scheduler:
+        jobs = scheduler.get_jobs()
+
+    for job in jobs:
+        typer.echo(f"[{job.id}] Next run: {job.next_run_time} | Trigger: {job.trigger}")
+
+
+@app.command()
+def force(job_id: str) -> None:
+    """Force the execution of (a) scheduler(s) based on a job_id."""
+    with get_paused_scheduler() as scheduler:
+        job = scheduler.get_job(job_id)
+
+    if not job:
+        typer.echo(f"Job '{job_id}' not found.")
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Running job [{job.id}] now...")
+    try:
+        job.func(*job.args or (), **job.kwargs or {})
+        typer.echo("Job executed successfully.")
+    except Exception as e:
+        typer.echo(f"Job execution failed: {e}")
+        raise typer.Exit(code=1)

orchestrator_core-4.4.0/orchestrator/graphql/resolvers/scheduled_tasks.py

@@ -0,0 +1,36 @@
+import structlog
+
+from orchestrator.db.filters import Filter
+from orchestrator.db.sorting import Sort
+from orchestrator.graphql.pagination import Connection
+from orchestrator.graphql.schemas.scheduled_task import ScheduledTaskGraphql
+from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
+from orchestrator.graphql.utils import create_resolver_error_handler, to_graphql_result_page
+from orchestrator.graphql.utils.is_query_detailed import is_querying_page_data
+from orchestrator.schedules.scheduler import get_scheduler_tasks, scheduled_task_filter_keys, scheduled_task_sort_keys
+
+logger = structlog.get_logger(__name__)
+
+
+async def resolve_scheduled_tasks(
+    info: OrchestratorInfo,
+    filter_by: list[GraphqlFilter] | None = None,
+    sort_by: list[GraphqlSort] | None = None,
+    first: int = 10,
+    after: int = 0,
+) -> Connection[ScheduledTaskGraphql]:
+    _error_handler = create_resolver_error_handler(info)
+
+    pydantic_filter_by: list[Filter] = [item.to_pydantic() for item in filter_by] if filter_by else []
+    pydantic_sort_by: list[Sort] = [item.to_pydantic() for item in sort_by] if sort_by else []
+    scheduled_tasks, total = get_scheduler_tasks(
+        first=first, after=after, filter_by=pydantic_filter_by, sort_by=pydantic_sort_by, error_handler=_error_handler
+    )
+
+    graphql_scheduled_tasks = []
+    if is_querying_page_data(info):
+        graphql_scheduled_tasks = [ScheduledTaskGraphql.from_pydantic(p) for p in scheduled_tasks]
+
+    return to_graphql_result_page(
+        graphql_scheduled_tasks, first, after, total, scheduled_task_filter_keys, scheduled_task_sort_keys
+    )

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/graphql/schema.py

@@ -51,12 +51,14 @@ from orchestrator.graphql.resolvers import (
     resolve_version,
     resolve_workflows,
 )
+from orchestrator.graphql.resolvers.scheduled_tasks import resolve_scheduled_tasks
 from orchestrator.graphql.schemas import DEFAULT_GRAPHQL_MODELS
 from orchestrator.graphql.schemas.customer import CustomerType
 from orchestrator.graphql.schemas.process import ProcessType
 from orchestrator.graphql.schemas.product import ProductType
 from orchestrator.graphql.schemas.product_block import ProductBlock
 from orchestrator.graphql.schemas.resource_type import ResourceType
+from orchestrator.graphql.schemas.scheduled_task import ScheduledTaskGraphql
 from orchestrator.graphql.schemas.settings import StatusType
 from orchestrator.graphql.schemas.subscription import SubscriptionInterface
 from orchestrator.graphql.schemas.version import VersionType
@@ -99,6 +101,9 @@ class OrchestratorQuery:
         description="Returns information about cache, workers, and global engine settings",
     )
     version: VersionType = authenticated_field(resolver=resolve_version, description="Returns version information")
+    scheduled_tasks: Connection[ScheduledTaskGraphql] = authenticated_field(
+        resolver=resolve_scheduled_tasks, description="Returns scheduled job information"
+    )
 
 
 @strawberry.federation.type(description="Orchestrator customer Query")

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/graphql/schemas/process.py

@@ -6,7 +6,7 @@ from strawberry.federation.schema_directives import Key
 from strawberry.scalars import JSON
 
 from oauth2_lib.strawberry import authenticated_field
-from orchestrator.api.api_v1.endpoints.processes import get_auth_callbacks, get_current_steps
+from orchestrator.api.api_v1.endpoints.processes import get_auth_callbacks, get_steps_to_evaluate_for_rbac
 from orchestrator.db import ProcessTable, ProductTable, db
 from orchestrator.graphql.pagination import EMPTY_PAGE, Connection
 from orchestrator.graphql.schemas.customer import CustomerType
@@ -82,11 +82,11 @@ class ProcessType:
         )
 
     @strawberry.field(description="Returns user permissions for operations on this process")  # type: ignore
-    def user_permissions(self, info: OrchestratorInfo) -> FormUserPermissionsType:
-        oidc_user = info.context.get_current_user
+    async def user_permissions(self, info: OrchestratorInfo) -> FormUserPermissionsType:
+        oidc_user = await info.context.get_current_user
         workflow = get_workflow(self.workflow_name)
         process = load_process(db.session.get(ProcessTable, self.process_id))  # type: ignore[arg-type]
-        auth_resume, auth_retry = get_auth_callbacks(get_current_steps(process), workflow)  # type: ignore[arg-type]
+        auth_resume, auth_retry = get_auth_callbacks(get_steps_to_evaluate_for_rbac(process), workflow)  # type: ignore[arg-type]
 
         return FormUserPermissionsType(
             retryAllowed=auth_retry and auth_retry(oidc_user),  # type: ignore[arg-type]

orchestrator_core-4.4.0/orchestrator/graphql/schemas/scheduled_task.py

@@ -0,0 +1,8 @@
+import strawberry
+
+from orchestrator.schedules.scheduler import ScheduledTask
+
+
+@strawberry.experimental.pydantic.type(model=ScheduledTask, all_fields=True)
+class ScheduledTaskGraphql:
+    pass

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/graphql/schemas/workflow.py

@@ -33,8 +33,8 @@ class Workflow:
         return [Step(name=step.name, assignee=step.assignee) for step in get_workflow(self.name).steps]  # type: ignore
 
     @strawberry.field(description="Return whether the currently logged-in used is allowed to start this workflow")  # type: ignore
-    def is_allowed(self, info: OrchestratorInfo) -> bool:
-        oidc_user = info.context.get_current_user
+    async def is_allowed(self, info: OrchestratorInfo) -> bool:
+        oidc_user = await info.context.get_current_user
         workflow_table = get_original_model(self, WorkflowTable)
         workflow = get_workflow(workflow_table.name)
 

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/graphql/utils/create_resolver_error_handler.py

@@ -25,6 +25,6 @@ def _format_context(context: dict) -> str:
 
 def create_resolver_error_handler(info: OrchestratorInfo) -> CallableErrorHandler:
     def handle_error(message: str, **context) -> None:  # type: ignore
-        return register_error(" ".join([message, _format_context(context)]), info, error_type=ErrorType.BAD_REQUEST)
+        return register_error(f"{message} {_format_context(context)}", info, error_type=ErrorType.BAD_REQUEST)
 
     return handle_error

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/schedules/__init__.py

@@ -13,12 +13,11 @@
 
 
 from orchestrator.schedules.resume_workflows import run_resume_workflows
-from orchestrator.schedules.scheduling import SchedulingFunction
 from orchestrator.schedules.task_vacuum import vacuum_tasks
 from orchestrator.schedules.validate_products import validate_products
 from orchestrator.schedules.validate_subscriptions import validate_subscriptions
 
-ALL_SCHEDULERS: list[SchedulingFunction] = [
+ALL_SCHEDULERS: list = [
     run_resume_workflows,
     vacuum_tasks,
     validate_subscriptions,

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/schedules/resume_workflows.py

@@ -12,10 +12,10 @@
 # limitations under the License.
 
 
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.processes import start_process
 
 
-@scheduler(name="Resume workflows", time_unit="hour", period=1)
+@scheduler.scheduled_job(id="resume-workflows", name="Resume workflows", trigger="interval", hours=1)  # type: ignore[misc]
 def run_resume_workflows() -> None:
     start_process("task_resume_workflows")

orchestrator_core-4.4.0/orchestrator/schedules/scheduler.py

@@ -0,0 +1,170 @@
+# Copyright 2019-2020 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from contextlib import contextmanager
+from datetime import datetime
+from typing import Any, Generator
+
+from apscheduler.executors.pool import ThreadPoolExecutor
+from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
+from apscheduler.schedulers.background import BackgroundScheduler
+from more_itertools import partition
+from pydantic import BaseModel
+
+from orchestrator.db.filters import Filter
+from orchestrator.db.filters.filters import CallableErrorHandler
+from orchestrator.db.sorting import Sort
+from orchestrator.db.sorting.sorting import SortOrder
+from orchestrator.settings import app_settings
+from orchestrator.utils.helpers import camel_to_snake, to_camel
+
+jobstores = {"default": SQLAlchemyJobStore(url=str(app_settings.DATABASE_URI))}
+executors = {
+    "default": ThreadPoolExecutor(1),
+}
+job_defaults = {
+    "coalesce": True,
+}
+
+scheduler = BackgroundScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults)
+
+
+def scheduler_dispose_db_connections() -> None:
+    jobstores["default"].engine.dispose()
+
+
+@contextmanager
+def get_paused_scheduler() -> Generator[BackgroundScheduler, Any, None]:
+    scheduler.start(paused=True)
+
+    try:
+        yield scheduler
+    finally:
+        scheduler.shutdown()
+        scheduler_dispose_db_connections()
+
+
+class ScheduledTask(BaseModel):
+    id: str
+    name: str | None = None
+    next_run_time: datetime | None = None
+    trigger: str
+
+
+scheduled_task_keys = set(ScheduledTask.model_fields.keys())
+scheduled_task_filter_keys = sorted(scheduled_task_keys | {to_camel(key) for key in scheduled_task_keys})
+scheduled_task_sort_keys = scheduled_task_filter_keys
+
+
+def scheduled_task_in_filter(job: ScheduledTask, filter_by: list[Filter]) -> bool:
+    return any(f.value.lower() in getattr(job, camel_to_snake(f.field), "").lower() for f in filter_by)
+
+
+def filter_scheduled_tasks(
+    scheduled_tasks: list[ScheduledTask],
+    handle_filter_error: CallableErrorHandler,
+    filter_by: list[Filter] | None = None,
+) -> list[ScheduledTask]:
+    if not filter_by:
+        return scheduled_tasks
+
+    try:
+        invalid_filters, valid_filters = partition(lambda x: x.field in scheduled_task_filter_keys, filter_by)
+
+        if invalid_list := [item.field for item in invalid_filters]:
+            handle_filter_error(
+                "Invalid filter arguments", invalid_filters=invalid_list, valid_filter_keys=scheduled_task_filter_keys
+            )
+
+        valid_filter_list = list(valid_filters)
+        return [task for task in scheduled_tasks if scheduled_task_in_filter(task, valid_filter_list)]
+    except Exception as e:
+        handle_filter_error(str(e))
+        return []
+
+
+def _invert(value: Any) -> Any:
+    """Invert value for descending order."""
+    if isinstance(value, (int, float)):
+        return -value
+    if isinstance(value, str):
+        return tuple(-ord(c) for c in value)
+    if isinstance(value, datetime):
+        return -value.timestamp()
+    return value
+
+
+def sort_key(sort_field: str, sort_order: SortOrder) -> Any:
+    def _sort_key(task: Any) -> Any:
+        value = getattr(task, camel_to_snake(sort_field), None)
+        if sort_field == "next_run_time" and value is None:
+            return float("inf") if sort_order == SortOrder.ASC else float("-inf")
+        return value if sort_order == SortOrder.ASC else _invert(value)
+
+    return _sort_key
+
+
+def sort_scheduled_tasks(
+    scheduled_tasks: list[ScheduledTask], handle_sort_error: CallableErrorHandler, sort_by: list[Sort] | None = None
+) -> list[ScheduledTask]:
+    if not sort_by:
+        return scheduled_tasks
+
+    try:
+        invalid_sorting, valid_sorting = partition(lambda x: x.field in scheduled_task_sort_keys, sort_by)
+        if invalid_list := [item.field for item in invalid_sorting]:
+            handle_sort_error(
+                "Invalid sort arguments", invalid_sorting=invalid_list, valid_sort_keys=scheduled_task_sort_keys
+            )
+
+        valid_sort_list = list(valid_sorting)
+        return sorted(
+            scheduled_tasks, key=lambda task: tuple(sort_key(sort.field, sort.order)(task) for sort in valid_sort_list)
+        )
+    except Exception as e:
+        handle_sort_error(str(e))
+        return []
+
+
+def default_error_handler(message: str, **context) -> None:  # type: ignore
+    from orchestrator.graphql.utils.create_resolver_error_handler import _format_context
+
+    raise ValueError(f"{message} {_format_context(context)}")
+
+
+def get_scheduler_tasks(
+    first: int = 10,
+    after: int = 0,
+    filter_by: list[Filter] | None = None,
+    sort_by: list[Sort] | None = None,
+    error_handler: CallableErrorHandler = default_error_handler,
+) -> tuple[list[ScheduledTask], int]:
+    with get_paused_scheduler() as pauzed_scheduler:
+        scheduled_tasks = pauzed_scheduler.get_jobs()
+
+    scheduled_tasks = filter_scheduled_tasks(scheduled_tasks, error_handler, filter_by)
+    scheduled_tasks = sort_scheduled_tasks(scheduled_tasks, error_handler, sort_by)
+
+    total = len(scheduled_tasks)
+    paginated_tasks = scheduled_tasks[after : after + first + 1]
+
+    return [
+        ScheduledTask(
+            id=task.id,
+            name=task.name,
+            next_run_time=task.next_run_time,
+            trigger=str(task.trigger),
+        )
+        for task in paginated_tasks
+    ], total

orchestrator_core-4.4.0/orchestrator/schedules/scheduling.py

@@ -0,0 +1,88 @@
+# Copyright 2019-2020 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable
+from typing import TypeVar
+
+from apscheduler.schedulers.base import BaseScheduler
+from deprecated import deprecated
+
+from orchestrator.schedules.scheduler import scheduler as default_scheduler  # your global scheduler instance
+
+F = TypeVar("F", bound=Callable[..., object])
+
+
+@deprecated(
+    reason="We changed from scheduler to apscheduler which has its own decoractor, use `@scheduler.scheduled_job()` from `from orchestrator.scheduling.scheduler import scheduler`"
+)
+def scheduler(
+    name: str,
+    time_unit: str,
+    period: int = 1,
+    at: str | None = None,
+    *,
+    id: str | None = None,
+    scheduler: BaseScheduler = default_scheduler,
+) -> Callable[[F], F]:
+    """APScheduler-compatible decorator to schedule a function.
+
+    id is necessary with apscheduler, if left empty it takes the function name.
+
+    - `time_unit = "hours", period = 12`  → every 12 hours
+    - `time_unit = "day", at = "01:00"`   → every day at 1 AM
+    """
+
+    def decorator(func: F) -> F:
+        job_id = id or func.__name__
+
+        trigger = "interval"
+        kwargs: dict[str, int] = {}
+        if time_unit == "day" and at:
+            trigger = "cron"
+            try:
+                hour, minute = map(int, at.split(":"))
+            except ValueError:
+                raise ValueError(f"Invalid time format for 'at': {at}, expected 'HH:MM'")
+
+            kwargs = {
+                "hour": hour,
+                "minute": minute,
+            }
+        else:
+            # Map string units to timedelta kwargs for IntervalTrigger
+            unit_map = {
+                "seconds": "seconds",
+                "second": "seconds",
+                "minutes": "minutes",
+                "minute": "minutes",
+                "hours": "hours",
+                "hour": "hours",
+                "days": "days",
+                "day": "days",
+            }
+
+            interval_arg = unit_map.get(time_unit.lower(), time_unit.lower())
+            kwargs = {interval_arg: period}
+
+        scheduler.add_job(
+            func,
+            trigger=trigger,
+            id=job_id,
+            name=name,
+            replace_existing=True,
+            **kwargs,
+        )
+
+        return func
+
+    return decorator

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/schedules/task_vacuum.py

@@ -12,10 +12,10 @@
 # limitations under the License.
 
 
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.processes import start_process
 
 
-@scheduler(name="Clean up tasks", time_unit="hours", period=6)
+@scheduler.scheduled_job(id="clean-tasks", name="Clean up tasks", trigger="interval", hours=6)  # type: ignore[misc]
 def vacuum_tasks() -> None:
     start_process("task_clean_up_tasks")

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/schedules/validate_products.py

@@ -14,11 +14,17 @@ from sqlalchemy import func, select
 
 from orchestrator.db import db
 from orchestrator.db.models import ProcessTable
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.processes import start_process
 
 
-@scheduler(name="Validate Products and inactive subscriptions", time_unit="day", at="02:30")
+@scheduler.scheduled_job(  # type: ignore[misc]
+    id="validate-products",
+    name="Validate Products and inactive subscriptions",
+    trigger="cron",
+    hour=2,
+    minute=30,
+)
 def validate_products() -> None:
     uncompleted_products = db.session.scalar(
         select(func.count())

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/schedules/validate_subscriptions.py

@@ -16,7 +16,7 @@ from threading import BoundedSemaphore
 
 import structlog
 
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.subscriptions import (
     get_subscriptions_on_product_table,
     get_subscriptions_on_product_table_in_sync,
@@ -33,7 +33,7 @@ logger = structlog.get_logger(__name__)
 task_semaphore = BoundedSemaphore(value=2)
 
 
-@scheduler(name="Subscriptions Validator", time_unit="day", at="00:10")
+@scheduler.scheduled_job(id="subscriptions-validator", name="Subscriptions Validator", trigger="cron", hour=0, minute=10)  # type: ignore[misc]
 def validate_subscriptions() -> None:
     if app_settings.VALIDATE_OUT_OF_SYNC_SUBSCRIPTIONS:
         # Automatically re-validate out-of-sync subscriptions. This is not recommended for production.

{orchestrator_core-4.3.0rc3 → orchestrator_core-4.4.0}/orchestrator/services/processes.py

@@ -733,11 +733,17 @@ def abort_process(process: ProcessTable, user: str, broadcast_func: Callable | N
 
 
 def _recoverwf(wf: Workflow, log: list[WFProcess]) -> tuple[WFProcess, StepList]:
-    # Remove all extra steps (Failed, Suspended and (A)waiting steps in db). Only keep cleared steps.
+    """Recover workflow state and remaining steps from the given 'Process step' objects.
 
-    persistent = list(
-        filter(lambda p: not (p.isfailed() or p.issuspend() or p.iswaiting() or p.isawaitingcallback()), log)
-    )
+    Returns:
+      - The state accumulated up until the last cleared (completed) step\
+      - The remaining steps to execute (including Failed, Suspended and (A)waiting steps)
+    """
+
+    def is_cleared(p: WFProcess) -> bool:
+        return not (p.isfailed() or p.issuspend() or p.iswaiting() or p.isawaitingcallback())
+
+    persistent = [p for p in log if is_cleared(p)]
     stepcount = len(persistent)
 
     if log and (log[-1].issuspend() or log[-1].isawaitingcallback()):
@@ -760,15 +766,14 @@ def _recoverwf(wf: Workflow, log: list[WFProcess]) -> tuple[WFProcess, StepList]
 
 
 def _restore_log(steps: list[ProcessStepTable]) -> list[WFProcess]:
-    result = []
-    for step in steps:
-        process = WFProcess.from_status(step.status, step.state)
+    """Deserialize ProcessStepTable objects into foldable 'Process step' objects."""
 
-        if not process:
-            raise ValueError(step.status)
+    def deserialize(step: ProcessStepTable) -> WFProcess:
+        if not (wf_process := WFProcess.from_status(step.status, step.state)):
+            raise ValueError(f"Unable to deserialize step from it's status {step.status}")
+        return wf_process
 
-        result.append(process)
-    return result
+    return [deserialize(step) for step in steps]
 
 
 def load_process(process: ProcessTable) -> ProcessStat: