orchestrator-core 4.3.0rc2__py3-none-any.whl → 4.4.0rc1__py3-none-any.whl

orchestrator/__init__.py

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

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/cli/scheduler.py

@@ -13,12 +13,11 @@
 
 
 import logging
-from time import sleep
 
-import schedule
 import typer
+from apscheduler.schedulers.blocking import BlockingScheduler
 
-from orchestrator.schedules import ALL_SCHEDULERS
+from orchestrator.schedules.scheduler import jobstores, scheduler, scheduler_dispose_db_connections
 
 log = logging.getLogger(__name__)
 
@@ -27,36 +26,47 @@ app: typer.Typer = typer.Typer()
 
 @app.command()
 def run() -> None:
-    """Loop eternally and run schedulers at configured times."""
-    for s in ALL_SCHEDULERS:
-        job = getattr(schedule.every(s.period), s.time_unit)
-        if s.at:
-            job = job.at(s.at)
-        job.do(s).tag(s.name)
-    log.info("Starting Schedule")
-    for j in schedule.jobs:
-        log.info("%s: %s", ", ".join(j.tags), j)
-    while True:
-        schedule.run_pending()
-        idle = schedule.idle_seconds()
-        if idle < 0:
-            log.info("Next job in queue is scheduled in the past, run it now.")
-        else:
-            log.info("Sleeping for %d seconds", idle)
-            sleep(idle)
+    """Start scheduler and loop eternally to keep thread alive."""
+    blocking_scheduler = BlockingScheduler(jobstores=jobstores)
+
+    try:
+        blocking_scheduler.start()
+    except (KeyboardInterrupt, SystemExit):
+        scheduler.shutdown()
+        scheduler_dispose_db_connections()
 
 
 @app.command()
 def show_schedule() -> None:
-    """Show the currently configured schedule."""
-    for s in ALL_SCHEDULERS:
-        at_str = f"@ {s.at} " if s.at else ""
-        typer.echo(f"{s.name}: {s.__name__} {at_str}every {s.period} {s.time_unit}")
+    """Show the currently configured schedule.
+
+    in cli underscore is replaced by a dash `show-schedule`
+    """
+    scheduler.start(paused=True)  # paused: avoid triggering jobs during CLI
+    jobs = scheduler.get_jobs()
+    scheduler.shutdown(wait=False)
+    scheduler_dispose_db_connections()
+
+    for job in jobs:
+        typer.echo(f"[{job.id}] Next run: {job.next_run_time} | Trigger: {job.trigger}")
 
 
 @app.command()
-def force(keyword: str) -> None:
-    """Force the execution of (a) scheduler(s) based on a keyword."""
-    for s in ALL_SCHEDULERS:
-        if keyword in s.name or keyword in s.__name__:
-            s()
+def force(job_id: str) -> None:
+    """Force the execution of (a) scheduler(s) based on a job_id."""
+    scheduler.start(paused=True)  # paused: avoid triggering jobs during CLI
+    job = scheduler.get_job(job_id)
+    scheduler.shutdown(wait=False)
+    scheduler_dispose_db_connections()
+
+    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/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/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/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
@@ -86,7 +86,7 @@ class ProcessType:
         oidc_user = 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/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/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/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/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/schedules/scheduler.py

@@ -0,0 +1,153 @@
+# 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 datetime import datetime
+from typing import Any
+
+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))}
+
+scheduler = BackgroundScheduler(jobstores=jobstores)
+
+
+def scheduler_dispose_db_connections() -> None:
+    jobstores["default"].engine.dispose()
+
+
+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]:
+    scheduler.start(paused=True)
+    scheduled_tasks = scheduler.get_jobs()
+    scheduler.shutdown(wait=False)
+    scheduler_dispose_db_connections()
+
+    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/schedules/scheduling.py

@@ -12,37 +12,77 @@
 # limitations under the License.
 
 from collections.abc import Callable
-from typing import Protocol, cast
+from typing import TypeVar
 
-from schedule import CancelJob
+from apscheduler.schedulers.base import BaseScheduler
+from deprecated import deprecated
 
+from orchestrator.schedules.scheduler import scheduler as default_scheduler  # your global scheduler instance
 
-class SchedulingFunction(Protocol):
-    __name__: str
-    name: str
-    time_unit: str
-    period: int | None
-    at: str | None
-
-    def __call__(self) -> CancelJob | None: ...
+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
-) -> Callable[[Callable[[], CancelJob | None]], SchedulingFunction]:
-    """Create schedule.
+    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.
 
-    Either specify the period or the at. Examples:
-    time_unit = "hours", period = 12 -> will run every 12 hours
-    time_unit = "day", at="01:00" -> will run every day at 1 o'clock
+    - `time_unit = "hours", period = 12`  → every 12 hours
+    - `time_unit = "day", at = "01:00"`   → every day at 1 AM
     """
 
-    def _scheduler(f: Callable[[], CancelJob | None]) -> SchedulingFunction:
-        schedule = cast(SchedulingFunction, f)
-        schedule.name = name
-        schedule.time_unit = time_unit
-        schedule.period = period
-        schedule.at = at
-        return schedule
+    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 _scheduler
+    return decorator

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/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/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/services/input_state.py

@@ -41,7 +41,7 @@ def retrieve_input_state(process_id: UUID, input_type: InputType, raise_exceptio
         select(InputStateTable)
         .filter(InputStateTable.process_id == process_id)
         .filter(InputStateTable.input_type == input_type)
-        .order_by(InputStateTable.input_time.asc())
+        .order_by(InputStateTable.input_time.desc())
     ).first()
 
     if res:

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:

orchestrator/workflow.py

@@ -552,7 +552,7 @@ class ProcessStat:
     process_id: UUID
     workflow: Workflow
     state: Process
-    log: StepList
+    log: StepList  # Remaining steps to execute
     current_user: str
     user_model: OIDCUserModel | None = None
 
@@ -597,6 +597,13 @@ class StepStatus(strEnum):
 
 
 class Process(Generic[S]):
+    """ADT base class.
+
+    This class defines an Algebraic Data Type - specifically a "sum type" - that defines the possible
+    variants of a Process. It encapsulates the state and allows to fold _instances_ of a process into
+    a single value. These instances correspond to subsequent steps of the process.
+    """
+
     def __init__(self, s: S):
         self.s = s
 

{orchestrator_core-4.3.0rc2.dist-info → orchestrator_core-4.4.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.3.0rc2
+Version: 4.4.0rc1
 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.0rc2.dist-info → orchestrator_core-4.4.0rc1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-orchestrator/__init__.py,sha256=k7E0AiB5QFgGg_GlFGkYHF-DTfhWCYkziVwvIXSWeAc,1066
+orchestrator/__init__.py,sha256=2VCmBMCQvlduTSR0AOWiSAcfGIGfm7kGJxYEKzqiXew,1066
 orchestrator/app.py,sha256=7UrXKjBKNSEaSSXAd5ww_RdMFhFqE4yvfj8faS2MzAA,12089
 orchestrator/exception_handlers.py,sha256=UsW3dw8q0QQlNLcV359bIotah8DYjMsj2Ts1LfX4ClY,1268
 orchestrator/log_config.py,sha256=1tPRX5q65e57a6a_zEii_PFK8SzWT0mnA5w2sKg4hh8,1853
@@ -8,7 +8,7 @@ orchestrator/settings.py,sha256=2Kgc6m3qUCcSM3Z_IVUeehfgO0QphMFkLrS0RC3sU-U,4365
 orchestrator/targets.py,sha256=WizBgnp8hWX9YLFUIju7ewSubiwQqinCvyiYNcXHbHI,802
 orchestrator/types.py,sha256=qzs7xx5AYRmKbpYRyJJP3wuDb0W0bcAzefCN0RWLAco,15459
 orchestrator/version.py,sha256=b58e08lxs47wUNXv0jXFO_ykpksmytuzEXD4La4W-NQ,1366
-orchestrator/workflow.py,sha256=PVHe6vnnkswzqw2UoY-j6NMSEhL6rLHXRnO7yLOyDC8,45551
+orchestrator/workflow.py,sha256=meDCPnyyX_n5PsMUaFy2wWb5EKNm1_ff7zRDBYrbcDg,45901
 orchestrator/api/__init__.py,sha256=GyHNfEFCGKQwRiN6rQmvSRH2iYX7npjMZn97n8XzmLU,571
 orchestrator/api/error_handling.py,sha256=YrPCxSa-DSa9KwqIMlXI-KGBGnbGIW5ukOPiikUH9E4,1502
 orchestrator/api/helpers.py,sha256=s0QRHYw8AvEmlkmRhuEzz9xixaZKUF3YuPzUVHkcoXk,6933
@@ -17,7 +17,7 @@ orchestrator/api/api_v1/__init__.py,sha256=GyHNfEFCGKQwRiN6rQmvSRH2iYX7npjMZn97n
 orchestrator/api/api_v1/api.py,sha256=m4iDktsSpzxUDaudkdgXeZ83a6B4wfc3pczQsa-Pb-8,2866
 orchestrator/api/api_v1/endpoints/__init__.py,sha256=GyHNfEFCGKQwRiN6rQmvSRH2iYX7npjMZn97n8XzmLU,571
 orchestrator/api/api_v1/endpoints/health.py,sha256=iaxs1XX1_250_gKNsspuULCV2GEMBjbtjsmfQTOvMAI,1284
-orchestrator/api/api_v1/endpoints/processes.py,sha256=kWz_jL8_sTNwl44tU17VwkwZGjBIw1IIW5pYCCSHwgs,15891
+orchestrator/api/api_v1/endpoints/processes.py,sha256=238Bydgj4ILNyMU_7j_Q7a0WGlfIvKv5ypP7lESU32w,16188
 orchestrator/api/api_v1/endpoints/product_blocks.py,sha256=kZ6ywIOsS_S2qGq7RvZ4KzjvaS1LmwbGWR37AKRvWOw,2146
 orchestrator/api/api_v1/endpoints/products.py,sha256=BfFtwu9dZXEQbtKxYj9icc73GKGvAGMR5ytyf41nQlQ,3081
 orchestrator/api/api_v1/endpoints/resource_types.py,sha256=gGyuaDyOD0TAVoeFGaGmjDGnQ8eQQArOxKrrk4MaDzA,2145
@@ -36,7 +36,7 @@ orchestrator/cli/migrate_domain_models.py,sha256=WRXy_1OnziQwpsCFZXvjB30nDJtjj0i
 orchestrator/cli/migrate_tasks.py,sha256=bju8XColjSZD0v3rS4kl-24dLr8En_H4-6enBmqd494,7255
 orchestrator/cli/migrate_workflows.py,sha256=nxUpx0vgEIc_8aJrjAyrw3E9Dt8JmaamTts8oiQ4vHY,8923
 orchestrator/cli/migration_helpers.py,sha256=C5tpkP5WEBr7G9S-1k1hgSI8ili6xd9Z5ygc9notaK0,4110
-orchestrator/cli/scheduler.py,sha256=iCKBWYUwQIYTDqKQ9rMVvs2sNiAzE-J2SkV170TPP2g,1896
+orchestrator/cli/scheduler.py,sha256=jdBbgqE7bNUOevFe6gZS5C-SyDTOow8baNJKEBTkS0A,2293
 orchestrator/cli/domain_gen_helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/cli/domain_gen_helpers/fixed_input_helpers.py,sha256=uzpwsaau81hHSxNMOS9-o7kF-9_78R0f_UE0AvWooZQ,6775
 orchestrator/cli/domain_gen_helpers/helpers.py,sha256=tIPxn8ezED_xYZxH7ZAtQLwkDc6RNmLZVxWAoJ3a9lw,4203
@@ -158,7 +158,7 @@ orchestrator/forms/validators/product_id.py,sha256=u5mURLT0pOhbFLdwvYcy2_2fXMt35
 orchestrator/graphql/__init__.py,sha256=avq8Yg3Jr_9pJqh7ClyIAOX7YSg1eM_AWmt5C3FRYUY,1440
 orchestrator/graphql/autoregistration.py,sha256=pF2jbMKG26MvYoMSa6ZpqpHjVks7_NvSRFymHTgmfjs,6342
 orchestrator/graphql/pagination.py,sha256=iqVDn3GPZpiQhEydfwkBJLURY-X8wwUphS8Lkeg0BOc,2413
-orchestrator/graphql/schema.py,sha256=gwZ3nAgKL0zlpc-aK58hSUAGPVD11Tb3aRSSK9hC39I,9204
+orchestrator/graphql/schema.py,sha256=dw4m4sM1ek2DscB8vINN6L8vVDE0h5GXclHGa8CiUJo,9537
 orchestrator/graphql/types.py,sha256=_kHKMusrRPuRtF4wm42NsBzoFZ4egbu3ibMmhd2D6Fs,5432
 orchestrator/graphql/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/graphql/extensions/model_cache.py,sha256=1uhMRjBs9eK7zJ1Y6P6BopX06822w2Yh9jliwYvG6yQ,1085
@@ -174,6 +174,7 @@ orchestrator/graphql/resolvers/process.py,sha256=Hqs1F7-gw0yO_ioHjh2eLAyxrK2WSuL
 orchestrator/graphql/resolvers/product.py,sha256=uPBmYwMdau-zUqNjoDl-LDn927u3aCFW5JQ4A_it8q0,2772
 orchestrator/graphql/resolvers/product_block.py,sha256=Ker1CpxGab5h2BZujOHHwRUj8W4uphRr3WSpQGk2PnI,2939
 orchestrator/graphql/resolvers/resource_type.py,sha256=SREZXjkLYpuo4nCM8DqVeImIrZcP3xDiWr_gq4wWaxQ,2956
+orchestrator/graphql/resolvers/scheduled_tasks.py,sha256=QsnesRrj8ESuS9vPKG9DXYcG2Wfj9m5LWGeZgmc6hu8,1640
 orchestrator/graphql/resolvers/settings.py,sha256=xVYqxo-EWQ24F4hUHm9OZeN9vsqQXJzIJ1_HF4Ci9Cs,3777
 orchestrator/graphql/resolvers/subscription.py,sha256=57niFv-JCro_wm0peJ5Ne04F2WIPuJ-Lx2h8yd9qubA,6541
 orchestrator/graphql/resolvers/version.py,sha256=qgwe1msPOexeg3RHCscJ8s45vNfMhYh9ZKyCZ3MNw30,809
@@ -184,17 +185,18 @@ orchestrator/graphql/schemas/customer_description.py,sha256=fize71IMpkvk_rTzcqCY
 orchestrator/graphql/schemas/errors.py,sha256=VRl-Zd1FHMnscyozhfxzqeEUZ0ERAWum_Y8YwjGxwmA,203
 orchestrator/graphql/schemas/fixed_input.py,sha256=1yqYHADQRgHz8OIP7ObYsPFS-gmzfkCvEO0a-KKf7zI,513
 orchestrator/graphql/schemas/helpers.py,sha256=Kpj4kIbmoKKN35bdgUSwQvGUIbeg7VJAVMEq65YS_ik,346
-orchestrator/graphql/schemas/process.py,sha256=nvD6Rvr0hnrMINdXF_rQuLF8szKJ7E-SywCFMuZsnlg,4940
+orchestrator/graphql/schemas/process.py,sha256=g3noYh_USfnaK59fnoX2DI5tAf1PhdLMJGI_lA2xX1M,4966
 orchestrator/graphql/schemas/product.py,sha256=vUCqcjrKBJj-VKSrMYPKzjmmxLMXL7alKTJ8UdUkhTg,4342
 orchestrator/graphql/schemas/product_block.py,sha256=Qk9cbA6vm7ZPrhdgPHatKRuy6TytBmxSr97McEOxAu8,2860
 orchestrator/graphql/schemas/resource_type.py,sha256=s5d_FwQXL2-Sc-IDUxTJun5qFQ4zOP4-XcHF9ql-t1g,898
+orchestrator/graphql/schemas/scheduled_task.py,sha256=22Kb7r2pUoefz9AeiTYQ1t6YBYCmAs_zVp7FqNdN5HQ,194
 orchestrator/graphql/schemas/settings.py,sha256=drhm5VcLmUbiYAk6WUSJcyJqjNM96E6GvpxVdPAobnA,999
 orchestrator/graphql/schemas/strawberry_pydantic_patch.py,sha256=CjNUhTKdYmLiaem-WY_mzw4HASIeaZitxGF8pPocqVw,1602
 orchestrator/graphql/schemas/subscription.py,sha256=hTA34C27kgLguH9V53173CxMKIWiQKh3vFzyJ2yBfE0,9918
 orchestrator/graphql/schemas/version.py,sha256=HSzVg_y4Sjd5_H5rRUtu3FJKOG_8ifhvBNt_qjOtC-E,92
 orchestrator/graphql/schemas/workflow.py,sha256=WLbegRNxOfvXg4kPYrO5KPBwtHmUofAr2pvZT2JsW1c,1761
 orchestrator/graphql/utils/__init__.py,sha256=1JvenzEVW1CBa1sGVI9I8IWnnoXIkb1hneDqph9EEZY,524
-orchestrator/graphql/utils/create_resolver_error_handler.py,sha256=PpQMVwGrE9t0nZ12TwoxPxksXxEwQM7lSNPeh7qW3vk,1233
+orchestrator/graphql/utils/create_resolver_error_handler.py,sha256=XzCnL482M4wz3fg5fUdGUwCAuzSZQ9Ufu1mscLyeoWU,1227
 orchestrator/graphql/utils/get_query_loaders.py,sha256=abS_HJ7K9een78gMiGq3IhwGwxQXHvZygExe0h_t9ns,815
 orchestrator/graphql/utils/get_selected_fields.py,sha256=0hBcQkU-7TNVO_KG-MmLItKm0O3gmbqoxXNkLHO-wHo,1002
 orchestrator/graphql/utils/get_selected_paths.py,sha256=H0btESeOr3_VB7zy5Cx25OS0uzBcg2Y1I-arAmSOnsQ,1382
@@ -208,6 +210,7 @@ orchestrator/metrics/init.py,sha256=xBITvDjbNf-iabbBg0tAW8TPj6-wzr_MerOOqgDsoS4,
 orchestrator/metrics/processes.py,sha256=SyogN5NSuhYoRv2CSUE1So9e8Gkrwa71J6oGLOdODQU,5333
 orchestrator/metrics/subscriptions.py,sha256=vC1O8VmTq5oJxNrn5CU99Rf8cxzdyhc7tXbZBSAU-O8,3036
 orchestrator/migrations/README,sha256=heMzebYwlGhnE8_4CWJ4LS74WoEZjBy-S-mIJRxAEKI,39
+orchestrator/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/migrations/alembic.ini,sha256=kMoADqhGeubU8xanILNaqm4oixLy9m4ngYtdGpZcc7I,873
 orchestrator/migrations/env.py,sha256=M_cPoAL2axuuup5fvMy8I_WTPHEw0RbPEHkhZ3QEGoE,3740
 orchestrator/migrations/helpers.py,sha256=CAGGKhxpmhyKGfYcO-SUCPfMTOCZPfEpkJrcm2MYfcE,47979
@@ -244,12 +247,13 @@ orchestrator/migrations/versions/schema/2025-05-08_161918133bec_add_is_task_to_w
 orchestrator/migrations/versions/schema/2025-07-01_93fc5834c7e5_changed_timestamping_fields_in_process_steps.py,sha256=Oezd8b2qaI1Kyq-sZFVFmdzd4d9NjXrf6HtJGk11fy0,1914
 orchestrator/migrations/versions/schema/2025-07-04_4b58e336d1bf_deprecating_workflow_target_in_.py,sha256=xnD6w-97R4ClS7rbmXQEXc36K3fdcXKhCy7ZZNy_FX4,742
 orchestrator/migrations/versions/schema/2025-07-28_850dccac3b02_update_description_of_resume_workflows_.py,sha256=R6Qoga83DJ1IL0WYPu0u5u2ZvAmqGlDmUMv_KtJyOhQ,812
-orchestrator/schedules/__init__.py,sha256=JnnaglfK1qYUBKI6Dd9taV-tCZIPlAdAkHtnkJDMXxY,1066
-orchestrator/schedules/resume_workflows.py,sha256=kSotzTAXjX7p9fpSYiGOpuxuTQfv54eRFAe0YSG0DHc,832
-orchestrator/schedules/scheduling.py,sha256=ehtwgpbvMOk1jhn-hHgVzg_9wLJkI6l3mRY3DcO9ZVY,1526
-orchestrator/schedules/task_vacuum.py,sha256=eovnuKimU8SFRw1IF62MsAVFSdgeeV1u57kapUbz8As,821
-orchestrator/schedules/validate_products.py,sha256=YMr7ASSqdXM6pd6oZu0kr8mfmH8If16MzprrsHdN_ZU,1234
-orchestrator/schedules/validate_subscriptions.py,sha256=9SYvsn4BJ5yo_1nu555hWjl5XffTx7QMaRhH5oOjM9E,2042
+orchestrator/schedules/__init__.py,sha256=Zy0fTOBMGIRFoh5iVFDLF9_PRAFaONYDThGK9EsysWo,981
+orchestrator/schedules/resume_workflows.py,sha256=jRnVRWDy687pQu-gtk80ecwiLSdrvtL15tG3U2zWA6I,891
+orchestrator/schedules/scheduler.py,sha256=vze3xaZhUL5maKQB6a1gCvc9AcGw3jX-BHT3d5xvy6A,5430
+orchestrator/schedules/scheduling.py,sha256=_mbpHMhijey8Y56ebtJ4wVkrp_kPVRm8hoByzlQF4SE,2821
+orchestrator/schedules/task_vacuum.py,sha256=mxb7fsy1GphRwvUWi_lvwNaj51YAXUdIDlkOJd90AFI,874
+orchestrator/schedules/validate_products.py,sha256=zWFQeVn3F8LP3joExLiKdmHs008pZsO-RolcIXHjFyE,1322
+orchestrator/schedules/validate_subscriptions.py,sha256=bUBV45aEuqVdtqYBAXh1lX4O5vuNTeTfds4J_zq35dI,2113
 orchestrator/schemas/__init__.py,sha256=YDyZ0YBvzB4ML9oDBCBPGnBvf680zFFgUzg7X0tYBRY,2326
 orchestrator/schemas/base.py,sha256=Vc444LetsINLRhG2SxW9Bq01hOzChPOhQWCImQTr-As,930
 orchestrator/schemas/engine_settings.py,sha256=LF8al7tJssiilb5A4emPtUYo0tVDSaT1Lvo_DN_ttrY,1296
@@ -264,9 +268,9 @@ orchestrator/schemas/subscription_descriptions.py,sha256=Ft_jw1U0bf9Z0U8O4OWfLlc
 orchestrator/schemas/workflow.py,sha256=VqQ9XfV4fVd6MjY0LRRQzWBJHmlPsAamWfTwDx1cZkg,2102
 orchestrator/services/__init__.py,sha256=GyHNfEFCGKQwRiN6rQmvSRH2iYX7npjMZn97n8XzmLU,571
 orchestrator/services/fixed_inputs.py,sha256=kyz7s2HLzyDulvcq-ZqefTw1om86COvyvTjz0_5CmgI,876
-orchestrator/services/input_state.py,sha256=WfiQrvatPtE1jR8xArE0XamONt1nemTv5iaROgSiJpM,2389
+orchestrator/services/input_state.py,sha256=6BZOpb3cHpO18K-XG-3QUIV9pIM25_ufdODrp5CmXG4,2390
 orchestrator/services/process_broadcast_thread.py,sha256=D44YbjF8mRqGuznkRUV4SoRn1J0lfy_x1H508GnSVlU,4649
-orchestrator/services/processes.py,sha256=JGM9vWbUjvEpy-IpTIgaYaqcTBKMI-CWTY8SJKBf3eI,30153
+orchestrator/services/processes.py,sha256=NfzdtH4eZK_wYuSmFtUX69qDvoeI8J7sJ2fFyY_VYaM,30544
 orchestrator/services/products.py,sha256=BP4KyE8zO-8z7Trrs5T6zKBOw53S9BfBJnHWI3p6u5Y,1943
 orchestrator/services/resource_types.py,sha256=_QBy_JOW_X3aSTqH0CuLrq4zBJL0p7Q-UDJUcuK2_qc,884
 orchestrator/services/settings.py,sha256=HEWfFulgoEDwgfxGEO__QTr5fDiwNBEj1UhAeTAdbLQ,3159
@@ -315,7 +319,7 @@ orchestrator/workflows/tasks/resume_workflows.py,sha256=T3iobSJjVgiupe0rClD34kUZ
 orchestrator/workflows/tasks/validate_product_type.py,sha256=paG-NAY1bdde3Adt8zItkcBKf5Pxw6f5ngGW6an6dYU,3192
 orchestrator/workflows/tasks/validate_products.py,sha256=GZJBoFF-WMphS7ghMs2-gqvV2iL1F0POhk0uSNt93n0,8510
 orchestrator/workflows/translations/en-GB.json,sha256=ST53HxkphFLTMjFHonykDBOZ7-P_KxksktZU3GbxLt0,846
-orchestrator_core-4.3.0rc2.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
-orchestrator_core-4.3.0rc2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-orchestrator_core-4.3.0rc2.dist-info/METADATA,sha256=aJsbvoK-FPIjx_tH3UJy3KWgj6aLhFwUb7tJvUxq9gQ,5963
-orchestrator_core-4.3.0rc2.dist-info/RECORD,,
+orchestrator_core-4.4.0rc1.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
+orchestrator_core-4.4.0rc1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+orchestrator_core-4.4.0rc1.dist-info/METADATA,sha256=as5RXg0Y5DUGPcpT-6raY0HmvEeDJfEMsg1dIQfqoqU,5967
+orchestrator_core-4.4.0rc1.dist-info/RECORD,,