orchestrator-core 2.9.2rc1__tar.gz → 2.9.2rc2__tar.gz

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 2.9.2rc1
+current_version = 2.9.2rc2
 commit = False
 tag = False
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(rc(?P<build>\d+))?

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: orchestrator-core
-Version: 2.9.2rc1
+Version: 2.9.2rc2
 Summary: This is the orchestrator workflow engine.
 Requires-Python: >=3.11,<3.14
 Classifier: Intended Audience :: Information Technology

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/orchestrator/__init__.py

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

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/orchestrator/db/filters/subscription.py

@@ -24,6 +24,7 @@ logger = structlog.get_logger(__name__)
 SUBSCRIPTION_TABLE_COLUMN_CLAUSES = default_inferred_column_clauses(SubscriptionTable) | {
     "product": inferred_filter(ProductTable.name),
     "tag": filter_exact(ProductTable.tag),
+    "type": filter_exact(ProductTable.product_type),
 }
 
 subscription_filter_fields = create_memoized_field_list(SUBSCRIPTION_TABLE_COLUMN_CLAUSES)

orchestrator_core-2.9.2rc2/orchestrator/migrations/versions/schema/2025-10-19_4fjdn13f83ga_add_validate_product_type_task.py

@@ -0,0 +1,41 @@
+"""Validate Product Type.
+
+Revision ID: 4fjdn13f83ga
+Revises: 2c7e8a43d4f9
+Create Date: 2025-10-13 16:21:43.956814
+
+"""
+
+from uuid import uuid4
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "4fjdn13f83ga"
+down_revision = "4c5859620539"
+branch_labels = None
+depends_on = None
+
+
+workflow = {
+    "name": "task_validate_product_type",
+    "target": "SYSTEM",
+    "description": "Validate all subscriptions of Product Type",
+    "workflow_id": uuid4(),
+}
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    conn.execute(
+        sa.text(
+            "INSERT INTO workflows VALUES (:workflow_id, :name, :target, :description, now()) ON CONFLICT DO NOTHING"
+        ),
+        workflow,
+    )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    conn.execute(sa.text("DELETE FROM workflows WHERE name = :name"), {"name": workflow["name"]})

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/orchestrator/schedules/validate_subscriptions.py

@@ -15,14 +15,17 @@
 from threading import BoundedSemaphore
 
 import structlog
-from sqlalchemy import select
 
-from orchestrator.db import ProductTable, SubscriptionTable, db
 from orchestrator.schedules.scheduling import scheduler
-from orchestrator.services.processes import get_execution_context
-from orchestrator.services.subscriptions import TARGET_DEFAULT_USABLE_MAP, WF_USABLE_MAP
+from orchestrator.services.subscriptions import (
+    get_subscriptions_on_product_table,
+    get_subscriptions_on_product_table_in_sync,
+)
+from orchestrator.services.workflows import (
+    get_system_product_workflows_for_subscription,
+    start_validation_workflow_for_workflows,
+)
 from orchestrator.settings import app_settings
-from orchestrator.targets import Target
 
 logger = structlog.get_logger(__name__)
 
@@ -34,29 +37,19 @@ task_semaphore = BoundedSemaphore(value=2)
 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.
-        select_query = select(SubscriptionTable).join(ProductTable)
+        subscriptions = get_subscriptions_on_product_table()
     else:
-        select_query = select(SubscriptionTable).join(ProductTable).filter(SubscriptionTable.insync.is_(True))
-    subscriptions = db.session.scalars(select_query)
-    for subscription in subscriptions:
-        validation_workflow = None
-
-        for workflow in subscription.product.workflows:
-            if workflow.target == Target.SYSTEM:
-                validation_workflow = workflow.name
-
-        if validation_workflow:
-            default = TARGET_DEFAULT_USABLE_MAP[Target.SYSTEM]
-            usable_when = WF_USABLE_MAP.get(validation_workflow, default)
+        subscriptions = get_subscriptions_on_product_table_in_sync()
 
-            if subscription.status in usable_when:
-                json = [{"subscription_id": str(subscription.subscription_id)}]
+    for subscription in subscriptions:
+        system_product_workflows = get_system_product_workflows_for_subscription(subscription)
 
-                validate_func = get_execution_context()["validate"]
-                validate_func(validation_workflow, json=json)
-        else:
+        if not system_product_workflows:
             logger.warning(
                 "SubscriptionTable has no validation workflow",
                 subscription=subscription,
                 product=subscription.product.name,
             )
+            break
+
+        start_validation_workflow_for_workflows(subscription=subscription, workflows=system_product_workflows)

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/orchestrator/services/subscriptions.py

@@ -670,3 +670,13 @@ def format_extended_domain_model(subscription: dict, filter_owner_relations: boo
         filter_instance_ids_on_subscription()
 
     return subscription
+
+
+def get_subscriptions_on_product_table() -> list[SubscriptionTable]:
+    select_query = select(SubscriptionTable).join(ProductTable)
+    return list(db.session.scalars(select_query))
+
+
+def get_subscriptions_on_product_table_in_sync(in_sync: bool = True) -> list[SubscriptionTable]:
+    select_query = select(SubscriptionTable).join(ProductTable).filter(SubscriptionTable.insync.is_(in_sync))
+    return list(db.session.scalars(select_query))

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/orchestrator/services/workflows.py

@@ -2,8 +2,14 @@ from collections.abc import Iterable
 
 from sqlalchemy import Select, select
 
-from orchestrator.db import WorkflowTable, db
+from orchestrator.db import (
+    SubscriptionTable,
+    WorkflowTable,
+    db,
+)
 from orchestrator.schemas import StepSchema, WorkflowSchema
+from orchestrator.services.subscriptions import TARGET_DEFAULT_USABLE_MAP, WF_USABLE_MAP
+from orchestrator.targets import Target
 from orchestrator.workflows import get_workflow
 
 
@@ -42,3 +48,43 @@ def get_workflows(
 
 def get_workflow_by_name(workflow_name: str) -> WorkflowTable | None:
     return db.session.scalar(select(WorkflowTable).where(WorkflowTable.name == workflow_name))
+
+
+def get_system_product_workflows_for_subscription(
+    subscription: SubscriptionTable,
+) -> list:
+    return [workflow.name for workflow in subscription.product.workflows if workflow.target == Target.SYSTEM]
+
+
+def start_validation_workflow_for_workflows(
+    subscription: SubscriptionTable,
+    workflows: list,
+    product_type_filter: str | None = None,
+) -> list:
+    """Start validation workflows for a subscription."""
+    result = []
+
+    for workflow_name in workflows:
+        default = TARGET_DEFAULT_USABLE_MAP[Target.SYSTEM]
+        usable_when = WF_USABLE_MAP.get(workflow_name, default)
+
+        if subscription.status in usable_when and (
+            product_type_filter is None or subscription.product.product_type == product_type_filter
+        ):
+            json = [{"subscription_id": str(subscription.subscription_id)}]
+
+            # against circular import
+            from orchestrator.services.processes import get_execution_context
+
+            validate_func = get_execution_context()["validate"]
+            validate_func(workflow_name, json=json)
+
+            result.append(
+                {
+                    "workflow_name": workflow_name,
+                    "subscription_id": subscription.subscription_id,
+                    "product_type": subscription.product.product_type,
+                }
+            )
+
+    return result

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/orchestrator/workflows/__init__.py

@@ -110,5 +110,6 @@ LazyWorkflowInstance(".modify_note", "modify_note")
 LazyWorkflowInstance(".tasks.cleanup_tasks_log", "task_clean_up_tasks")
 LazyWorkflowInstance(".tasks.resume_workflows", "task_resume_workflows")
 LazyWorkflowInstance(".tasks.validate_products", "task_validate_products")
+LazyWorkflowInstance(".tasks.validate_product_type", "task_validate_product_type")
 
 __doc__ = make_workflow_index_doc(ALL_WORKFLOWS)

orchestrator_core-2.9.2rc2/orchestrator/workflows/tasks/validate_product_type.py

@@ -0,0 +1,92 @@
+# Copyright 2019-2024 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 functools import cache
+from typing import Any
+
+import structlog
+
+from orchestrator.db import ProductTable
+from orchestrator.forms import FormPage
+from orchestrator.forms.validators import Choice
+from orchestrator.services.subscriptions import (
+    get_subscriptions_on_product_table_in_sync,
+)
+from orchestrator.services.workflows import (
+    get_system_product_workflows_for_subscription,
+    start_validation_workflow_for_workflows,
+)
+from orchestrator.targets import Target
+from orchestrator.types import FormGenerator, State
+from orchestrator.workflow import StepList, done, init, step, workflow
+
+logger = structlog.get_logger(__name__)
+
+
+def create_select_product_type_form() -> type[FormPage]:
+    """Get and create the choices form for the product type."""
+
+    @cache
+    def get_product_type_choices() -> dict[Any, Any]:
+        return {product.product_type: product.product_type for product in ProductTable.query.all()}
+
+    ProductTypeChoices = Choice.__call__("Product Type", get_product_type_choices())
+
+    class SelectProductTypeForm(FormPage):
+        product_type: ProductTypeChoices  # type: ignore
+
+    return SelectProductTypeForm
+
+
+def initial_input_form_generator() -> FormGenerator:
+    """Generate the form."""
+
+    init_input = yield create_select_product_type_form()
+    user_input_data = init_input.model_dump()
+
+    return user_input_data
+
+
+@step("Validate Product Type")
+def validate_product_type(product_type: str) -> State:
+    result = []
+    subscriptions = get_subscriptions_on_product_table_in_sync()
+
+    for subscription in subscriptions:
+        system_product_workflows = get_system_product_workflows_for_subscription(
+            subscription=subscription,
+        )
+
+        if not system_product_workflows:
+            logger.warning(
+                "SubscriptionTable has no validation workflow",
+                subscription=subscription,
+                product=subscription.product.name,
+            )
+            continue
+
+        validation_result = start_validation_workflow_for_workflows(
+            subscription=subscription,
+            workflows=system_product_workflows,
+            product_type_filter=product_type,
+        )
+        if len(validation_result) > 0:
+            result.append({"total_workflows_validated": len(validation_result), "workflows": validation_result})
+
+    return {"result": result}
+
+
+@workflow(
+    "Validate all subscriptions of Product Type", target=Target.SYSTEM, initial_input_form=initial_input_form_generator
+)
+def task_validate_product_type() -> StepList:
+    return init >> validate_product_type >> done

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/orchestrator/workflows/translations/en-GB.json

@@ -5,7 +5,8 @@
             "note_info": "Notes, reminders and feedback about this description.",
             "subscription_id": "Subscription",
             "version": "Version",
-            "subscription_id_info": "The subscription for this action"
+            "subscription_id_info": "The subscription for this action",
+            "product_type": "Product Type"
         }
     },
     "workflow": {
@@ -13,6 +14,7 @@
         "task_clean_up_tasks": "Clean up old tasks",
         "task_resume_workflows": "Resume all workflows that are stuck on tasks with the status 'waiting'",
         "task_validate_products": "Validate Products and Subscriptions",
+        "task_validate_product_type": "Validate all subscriptions of Product Type",
         "reset_subscription_description": "Reset description of a subscription to default"
     }
 }

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/test/unit_tests/graphql/test_subscriptions.py

@@ -767,6 +767,35 @@ def test_subscriptions_range_filtering_on_start_date(test_client, product_type_1
         assert higher_than_date <= subscription["startDate"] <= lower_than_date
 
 
+def test_subscriptions_range_filtering_on_type(test_client, product_type_1_subscriptions_factory):
+    # when
+
+    product_type_1_subscriptions_factory(15)
+
+    data = get_subscriptions_query(filter_by=[{"field": "type", "value": "Test"}])
+    response = test_client.post("/api/graphql", content=data, headers={"Content-Type": "application/json"})
+
+    # then
+
+    assert HTTPStatus.OK == response.status_code
+    result = response.json()
+    subscriptions_data = result["data"]["subscriptions"]
+    subscriptions = subscriptions_data["page"]
+    pageinfo = subscriptions_data["pageInfo"]
+
+    assert "errors" not in result
+    assert pageinfo == {
+        "hasPreviousPage": False,
+        "hasNextPage": False,
+        "startCursor": 0,
+        "endCursor": 2,
+        "totalItems": 3,
+    }
+
+    for subscription in subscriptions:
+        assert subscription["product"]["productType"] == "Test"
+
+
 def test_subscriptions_filtering_with_invalid_filter(
     test_client, product_type_1_subscriptions_factory, generic_product_type_1
 ):
@@ -804,7 +833,7 @@ def test_subscriptions_filtering_with_invalid_filter(
             "message": (
                 "Invalid filter arguments (invalid_filters=['test'] "
                 "valid_filter_keys=['customerId', 'description', 'endDate', 'insync', "
-                "'note', 'product', 'productId', 'startDate', 'status', 'subscriptionId', 'tag', 'version'])"
+                "'note', 'product', 'productId', 'startDate', 'status', 'subscriptionId', 'tag', 'type', 'version'])"
             ),
             "path": ["subscriptions"],
             "extensions": {"error_type": "bad_request"},

{orchestrator_core-2.9.2rc1 → orchestrator_core-2.9.2rc2}/test/unit_tests/graphql/test_workflows.py

@@ -86,7 +86,7 @@ def test_workflows_query(test_client):
         "hasNextPage": True,
         "startCursor": 0,
         "endCursor": 1,
-        "totalItems": 4,
+        "totalItems": 5,
     }
 
 
@@ -105,14 +105,15 @@ def test_workflows_has_previous_page(test_client):
         "hasNextPage": False,
         "hasPreviousPage": True,
         "startCursor": 1,
-        "endCursor": 3,
-        "totalItems": 4,
+        "endCursor": 4,
+        "totalItems": 5,
     }
 
-    assert len(workflows) == 3
+    assert len(workflows) == 4
     assert [workflow["name"] for workflow in workflows] == [
         "task_clean_up_tasks",
         "task_resume_workflows",
+        "task_validate_product_type",
         "task_validate_products",
     ]
 
@@ -135,13 +136,18 @@ def test_workflows_filter_by_name(test_client, query_args):
 
     assert "errors" not in result
     assert pageinfo == {
-        "endCursor": 2,
+        "endCursor": 3,
         "hasNextPage": False,
         "hasPreviousPage": False,
         "startCursor": 0,
-        "totalItems": 3,
+        "totalItems": 4,
     }
-    expected_workflows = ["task_clean_up_tasks", "task_resume_workflows", "task_validate_products"]
+    expected_workflows = [
+        "task_clean_up_tasks",
+        "task_resume_workflows",
+        "task_validate_product_type",
+        "task_validate_products",
+    ]
     assert [rt["name"] for rt in workflows] == expected_workflows
 
 
@@ -209,8 +215,14 @@ def test_workflows_sort_by_resource_type_desc(test_client):
         "hasNextPage": False,
         "hasPreviousPage": False,
         "startCursor": 0,
-        "endCursor": 3,
-        "totalItems": 4,
+        "endCursor": 4,
+        "totalItems": 5,
     }
-    expected_workflows = ["task_validate_products", "task_resume_workflows", "task_clean_up_tasks", "modify_note"]
+    expected_workflows = [
+        "task_validate_products",
+        "task_validate_product_type",
+        "task_resume_workflows",
+        "task_clean_up_tasks",
+        "modify_note",
+    ]
     assert [rt["name"] for rt in workflows] == expected_workflows

orchestrator_core-2.9.2rc2/test/unit_tests/workflows/tasks/test_validate_product_type.py

@@ -0,0 +1,39 @@
+import pytest
+
+from orchestrator.db import SubscriptionTable, db
+from orchestrator.targets import Target
+from test.unit_tests.workflows import (
+    assert_complete,
+    extract_state,
+    run_workflow,
+)
+
+
+@pytest.mark.workflow
+def test_check_subscriptions(generic_subscription_1, validation_workflow_instance):
+    product = db.session.get(SubscriptionTable, generic_subscription_1).product
+    product.workflows.append(validation_workflow_instance)
+    db.session.add(product)
+    db.session.commit()
+
+    init_data = {
+        "product_type": "Generic",
+    }
+
+    result, process, step_log = run_workflow("task_validate_product_type", init_data)
+
+    assert_complete(result)
+
+    state = extract_state(result)
+
+    assert state["product_type"] == "Generic"
+    assert state["workflow_name"] == "task_validate_product_type"
+    assert state["workflow_target"] == Target.SYSTEM
+
+    result = state["result"]
+
+    assert len(result) == 1
+    assert result[0]["total_workflows_validated"] == 1
+    assert len(result[0]["workflows"]) == 1
+    assert result[0]["workflows"][0]["workflow_name"] == "validation_workflow"
+    assert result[0]["workflows"][0]["product_type"] == "Generic"