orchestrator-core 4.3.1__py3-none-any.whl → 4.4.0__py3-none-any.whl

orchestrator/__init__.py

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

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

@@ -13,12 +13,13 @@
 
 
 import logging
-from time import sleep
+import time
 
-import schedule
 import typer
 
-from orchestrator.schedules import ALL_SCHEDULERS
+from orchestrator.schedules.scheduler import (
+    get_paused_scheduler,
+)
 
 log = logging.getLogger(__name__)
 
@@ -27,36 +28,41 @@ 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."""
+    with get_paused_scheduler() as scheduler:
+        scheduler.resume()
+
+        while True:
+            time.sleep(1)
 
 
 @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`
+    """
+    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(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."""
+    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/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

@@ -82,8 +82,8 @@ 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_steps_to_evaluate_for_rbac(process), workflow)  # 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/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/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,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/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/subscriptions.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 
 """Module that provides service functions on subscriptions."""
+
 import pickle  # noqa: S403
 from collections import defaultdict
 from collections.abc import Sequence
@@ -506,6 +507,7 @@ TARGET_DEFAULT_USABLE_MAP: dict[Target, list[str]] = {
     Target.TERMINATE: ["active", "provisioning"],
     Target.SYSTEM: ["active"],
     Target.VALIDATE: ["active"],
+    Target.RECONCILE: ["active"],
 }
 
 WF_USABLE_MAP: dict[str, list[str]] = {}
@@ -532,6 +534,7 @@ def subscription_workflows(subscription: SubscriptionTable) -> dict[str, Any]:
         ...     "terminate": [],
         ...     "system": [],
         ...     "validate": [],
+        ...     "reconcile: [],
         ... }
 
     """
@@ -552,6 +555,7 @@ def subscription_workflows(subscription: SubscriptionTable) -> dict[str, Any]:
         "terminate": [],
         "system": [],
         "validate": [],
+        "reconcile": [],
     }
     for workflow in subscription.product.workflows:
         if workflow.name in WF_USABLE_WHILE_OUT_OF_SYNC or workflow.is_task:

orchestrator/targets.py

@@ -23,3 +23,4 @@ class Target(strEnum):
     TERMINATE = "TERMINATE"
     SYSTEM = "SYSTEM"
     VALIDATE = "VALIDATE"
+    RECONCILE = "RECONCILE"

orchestrator/workflows/utils.py

@@ -154,7 +154,7 @@ def _generate_modify_form(workflow_target: str, workflow_name: str) -> InputForm
 
 
 def wrap_modify_initial_input_form(initial_input_form: InputStepFunc | None) -> StateInputStepFunc | None:
-    """Wrap initial input for modify and terminate workflows.
+    """Wrap initial input for modify, reconcile and terminate workflows.
 
     This is needed because the frontend expects all modify workflows to start with a page that only contains the
     subscription id. It also expects the second page to have some user visible inputs and the subscription id *again*.
@@ -355,6 +355,53 @@ def validate_workflow(description: str) -> Callable[[Callable[[], StepList]], Wo
     return _validate_workflow
 
 
+def reconcile_workflow(
+    description: str,
+    additional_steps: StepList | None = None,
+    authorize_callback: Authorizer | None = None,
+    retry_auth_callback: Authorizer | None = None,
+) -> Callable[[Callable[[], StepList]], Workflow]:
+    """Similar to a modify_workflow but without required input user input to perform a sync with external systems based on the subscriptions existing configuration.
+
+    Use this for subscription reconcile workflows.
+
+    Example::
+
+        @reconcile_workflow("Reconcile l2vpn")
+        def reconcile_l2vpn() -> StepList:
+            return (
+                begin
+                >> update_l2vpn_in_external_systems
+            )
+    """
+
+    wrapped_reconcile_initial_input_form_generator = wrap_modify_initial_input_form(None)
+
+    def _reconcile_workflow(f: Callable[[], StepList]) -> Workflow:
+        steplist = (
+            init
+            >> store_process_subscription()
+            >> unsync
+            >> f()
+            >> (additional_steps or StepList())
+            >> resync
+            >> refresh_subscription_search_index
+            >> done
+        )
+
+        return make_workflow(
+            f,
+            description,
+            wrapped_reconcile_initial_input_form_generator,
+            Target.RECONCILE,
+            steplist,
+            authorize_callback=authorize_callback,
+            retry_auth_callback=retry_auth_callback,
+        )
+
+    return _reconcile_workflow
+
+
 def ensure_provisioning_status(modify_steps: Step | StepList) -> StepList:
     """Decorator to ensure subscription modifications are executed only during Provisioning status."""
     return (

{orchestrator_core-4.3.1.dist-info → orchestrator_core-4.4.0.dist-info}/METADATA

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

@@ -1,11 +1,11 @@
-orchestrator/__init__.py,sha256=A485Z6oxvKfpqVhk24XIbDwJZrxQE0dCBgzWyjrzkOw,1063
+orchestrator/__init__.py,sha256=mRsVPvC1u2rI_N-BlO3WFwcBGnHqkbyV8Ck2axmu3w0,1063
 orchestrator/app.py,sha256=7UrXKjBKNSEaSSXAd5ww_RdMFhFqE4yvfj8faS2MzAA,12089
 orchestrator/exception_handlers.py,sha256=UsW3dw8q0QQlNLcV359bIotah8DYjMsj2Ts1LfX4ClY,1268
 orchestrator/log_config.py,sha256=1tPRX5q65e57a6a_zEii_PFK8SzWT0mnA5w2sKg4hh8,1853
 orchestrator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/security.py,sha256=iXFxGxab54aav7oHEKLAVkTgrQMJGHy6IYLojEnD7gI,2422
 orchestrator/settings.py,sha256=2Kgc6m3qUCcSM3Z_IVUeehfgO0QphMFkLrS0RC3sU-U,4365
-orchestrator/targets.py,sha256=WizBgnp8hWX9YLFUIju7ewSubiwQqinCvyiYNcXHbHI,802
+orchestrator/targets.py,sha256=d7Fyh_mWIWPivA_E7DTNFpZID3xFW_K0JlZ5nksVX7k,830
 orchestrator/types.py,sha256=qzs7xx5AYRmKbpYRyJJP3wuDb0W0bcAzefCN0RWLAco,15459
 orchestrator/version.py,sha256=b58e08lxs47wUNXv0jXFO_ykpksmytuzEXD4La4W-NQ,1366
 orchestrator/workflow.py,sha256=meDCPnyyX_n5PsMUaFy2wWb5EKNm1_ff7zRDBYrbcDg,45901
@@ -23,7 +23,7 @@ orchestrator/api/api_v1/endpoints/products.py,sha256=BfFtwu9dZXEQbtKxYj9icc73GKG
 orchestrator/api/api_v1/endpoints/resource_types.py,sha256=gGyuaDyOD0TAVoeFGaGmjDGnQ8eQQArOxKrrk4MaDzA,2145
 orchestrator/api/api_v1/endpoints/settings.py,sha256=5s-k169podZjgGHUbVDmSQwpY_3Cs_Bbf2PPtZIkBcw,6184
 orchestrator/api/api_v1/endpoints/subscription_customer_descriptions.py,sha256=1_6LtgQleoq3M6z_W-Qz__Bj3OFUweoPrUqHMwSH6AM,3288
-orchestrator/api/api_v1/endpoints/subscriptions.py,sha256=zn_LeVfmp2uw7CszK4BvQ5n37hZccy3K2htkoDgF1sI,9809
+orchestrator/api/api_v1/endpoints/subscriptions.py,sha256=7KaodccUiMkcVnrFnK2azp_V_-hGudcIyhov5WwVGQY,9810
 orchestrator/api/api_v1/endpoints/translations.py,sha256=dIWh_fCnZZUxJoGiNeJ49DK_xpf75IpR_0EIMSvzIvY,963
 orchestrator/api/api_v1/endpoints/user.py,sha256=RyI32EXVu6I-IxWjz0XB5zQWzzLL60zKXLgLqLH02xU,1827
 orchestrator/api/api_v1/endpoints/workflows.py,sha256=_0vhGiQeu3-z16Zi0WmuDWBs8gmed6BzRNwYH_sF6AY,1977
@@ -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=2q6xT_XVOodY3e_qzIV98MWNvKvrbFpOJajWesj1fcs,1911
 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=g3noYh_USfnaK59fnoX2DI5tAf1PhdLMJGI_lA2xX1M,4966
+orchestrator/graphql/schemas/process.py,sha256=wN4pKDuPbPHyyfGYaqFXMXxKTDm_zIwmyCOhSu5H1Iw,4978
 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/schemas/workflow.py,sha256=ewE5mRuqMq7rnx8Au2eTUm3YTY1pivOWATNacZQ-trY,1773
 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
@@ -245,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=_Y6TB-GKNJM0Nk7CRLuMnw0djFEBrDm999GOOcBuBeQ,5880
+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
@@ -273,7 +276,7 @@ orchestrator/services/resource_types.py,sha256=_QBy_JOW_X3aSTqH0CuLrq4zBJL0p7Q-U
 orchestrator/services/settings.py,sha256=HEWfFulgoEDwgfxGEO__QTr5fDiwNBEj1UhAeTAdbLQ,3159
 orchestrator/services/settings_env_variables.py,sha256=iPErQjqPQCxKs0sPhefB16d8SBBVUi6eiRnFBK5bgqA,2196
 orchestrator/services/subscription_relations.py,sha256=aIdyzwyyy58OFhwjRPCPgnQTUTmChu6SeSQRIleQoDE,13138
-orchestrator/services/subscriptions.py,sha256=nr2HI89nC0lYjzTh2j-lEQ5cPQK43LNZv3gvP6jbepw,27189
+orchestrator/services/subscriptions.py,sha256=XhJ5ygAAyWUIZHULhKyi1uU5DwkKZhzdxxn9vdQZYiA,27281
 orchestrator/services/tasks.py,sha256=mR3Fj1VsudltpanJKI2PvrxersyhVQ1skp8H7r3XnYI,5288
 orchestrator/services/translations.py,sha256=GyP8soUFGej8AS8uulBsk10CCK6Kwfjv9AHMFm3ElQY,1713
 orchestrator/services/workflows.py,sha256=iEkt2OBuTwkDru4V6ZSKatnw0b96ZdPV-VQqeZ9EOgU,4015
@@ -309,14 +312,14 @@ orchestrator/workflows/__init__.py,sha256=NzIGGI-8SNAwCk2YqH6sHhEWbgAY457ntDwjO1
 orchestrator/workflows/modify_note.py,sha256=eXt5KQvrkOXf-3YEXCn2XbBLP9N-n1pUYRW2t8Odupo,2150
 orchestrator/workflows/removed_workflow.py,sha256=V0Da5TEdfLdZZKD38ig-MTp3_IuE7VGqzHHzvPYQmLI,909
 orchestrator/workflows/steps.py,sha256=CZxfzkG5ANJYwuYTkQ4da2RpQqIjXCtey_Uy1ezRAZ4,6479
-orchestrator/workflows/utils.py,sha256=bhX9vm3oc9k6RSaESl34v4Nrh40G4Ys91INoTjZ0XVM,13966
+orchestrator/workflows/utils.py,sha256=VUCDoIl5XAKtIeAJpVpyW2pCIg3PoVWfwGn28BYlYhA,15424
 orchestrator/workflows/tasks/__init__.py,sha256=GyHNfEFCGKQwRiN6rQmvSRH2iYX7npjMZn97n8XzmLU,571
 orchestrator/workflows/tasks/cleanup_tasks_log.py,sha256=BfWYbPXhnLAHUJ0mlODDnjZnQQAvKCZJDVTwbwOWI04,1624
 orchestrator/workflows/tasks/resume_workflows.py,sha256=T3iobSJjVgiupe0rClD34kUZ7KF4pL5yK2AVeRLZog8,4313
 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.1.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
-orchestrator_core-4.3.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-orchestrator_core-4.3.1.dist-info/METADATA,sha256=1lkABfKjfjXMQaj6Iw3CcmCkunXswkZ0RBLe61A1fAY,5960
-orchestrator_core-4.3.1.dist-info/RECORD,,
+orchestrator_core-4.4.0.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
+orchestrator_core-4.4.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+orchestrator_core-4.4.0.dist-info/METADATA,sha256=097W21kPObcri-l74UPc7CdMTBaeHobEeCXn_uqJu1Y,5964
+orchestrator_core-4.4.0.dist-info/RECORD,,