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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.2.0rc3
+Version: 4.3.0
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14

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

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

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

@@ -48,6 +48,7 @@ from orchestrator.services.processes import (
     _async_resume_processes,
     _get_process,
     abort_process,
+    can_be_resumed,
     continue_awaiting_process,
     load_process,
     resume_process,
@@ -120,16 +121,6 @@ def get_auth_callbacks(steps: StepList, workflow: Workflow) -> tuple[Authorizer
     return auth_resume, auth_retry
 
 
-def can_be_resumed(status: ProcessStatus) -> bool:
-    return status in (
-        ProcessStatus.SUSPENDED,  # Can be resumed
-        ProcessStatus.WAITING,  # Can be retried
-        ProcessStatus.FAILED,  # Can be retried
-        ProcessStatus.API_UNAVAILABLE,  # subtype of FAILED
-        ProcessStatus.INCONSISTENT_DATA,  # subtype of FAILED
-    )
-
-
 def resolve_user_name(
     *,
     reporter: Reporter | None,

{orchestrator_core-4.2.0rc3 → orchestrator_core-4.3.0}/orchestrator/graphql/loaders/subscriptions.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Literal
 from uuid import UUID
 
@@ -8,7 +9,11 @@ from strawberry.dataloader import DataLoader
 from orchestrator.db import (
     SubscriptionTable,
 )
-from orchestrator.services.subscription_relations import get_depends_on_subscriptions, get_in_use_by_subscriptions
+from orchestrator.services.subscription_relations import (
+    get_depends_on_subscriptions,
+    get_in_use_by_subscriptions,
+    get_last_validation_datetimes,
+)
 from orchestrator.types import SubscriptionLifecycle
 
 logger = structlog.get_logger(__name__)
@@ -38,4 +43,10 @@ async def depends_on_subs_loader(keys: list[tuple[UUID, tuple[str, ...]]]) -> li
     return await get_depends_on_subscriptions(subscription_ids, filter_statuses)
 
 
+async def last_validation_datetime_loader(keys: list[UUID]) -> list[datetime | None]:
+    """GraphQL dataloader to efficiently get the last validation datetime for multiple subscription_ids."""
+    return await get_last_validation_datetimes(keys)
+
+
 SubsLoaderType = DataLoader[tuple[UUID, tuple[str, ...]], list[SubscriptionTable]]
+LastValidationLoaderType = DataLoader[UUID, datetime | None]

{orchestrator_core-4.2.0rc3 → orchestrator_core-4.3.0}/orchestrator/graphql/schemas/subscription.py

@@ -175,6 +175,10 @@ class SubscriptionInterface:
         ]
         return await resolve_subscriptions(info, filter_by_with_related_subscriptions, sort_by, first, after)
 
+    @strawberry.field(description="Returns the date and time of the last validation workflow run for a subscription")  # type: ignore
+    async def last_validated_at(self, info: OrchestratorInfo) -> datetime | None:
+        return await info.context.core_last_validation_datetime_loader.load(self.subscription_id)
+
     @strawberry.field(description="Returns customer of a subscription")  # type: ignore
     def customer(self) -> CustomerType:
         return CustomerType(

{orchestrator_core-4.2.0rc3 → orchestrator_core-4.3.0}/orchestrator/graphql/types.py

@@ -30,7 +30,13 @@ from oauth2_lib.fastapi import AuthManager
 from oauth2_lib.strawberry import OauthContext
 from orchestrator.db.filters import Filter
 from orchestrator.db.sorting import Sort, SortOrder
-from orchestrator.graphql.loaders.subscriptions import SubsLoaderType, depends_on_subs_loader, in_use_by_subs_loader
+from orchestrator.graphql.loaders.subscriptions import (
+    LastValidationLoaderType,
+    SubsLoaderType,
+    depends_on_subs_loader,
+    in_use_by_subs_loader,
+    last_validation_datetime_loader,
+)
 from orchestrator.services.process_broadcast_thread import ProcessDataBroadcastThread
 
 StrawberryPydanticModel = TypeVar("StrawberryPydanticModel", bound=StrawberryTypeFromPydantic)
@@ -60,6 +66,9 @@ class OrchestratorContext(OauthContext):
         self.graphql_models = graphql_models or {}
         self.core_in_use_by_subs_loader: SubsLoaderType = DataLoader(load_fn=in_use_by_subs_loader)
         self.core_depends_on_subs_loader: SubsLoaderType = DataLoader(load_fn=depends_on_subs_loader)
+        self.core_last_validation_datetime_loader: LastValidationLoaderType = DataLoader(
+            load_fn=last_validation_datetime_loader
+        )
         super().__init__(auth_manager)
 
 

orchestrator_core-4.3.0/orchestrator/migrations/versions/schema/2025-07-28_850dccac3b02_update_description_of_resume_workflows_.py

@@ -0,0 +1,35 @@
+"""Update description of resume workflows task.
+
+Revision ID: 850dccac3b02
+Revises: 93fc5834c7e5
+Create Date: 2025-07-28 15:38:57.211087
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "850dccac3b02"
+down_revision = "93fc5834c7e5"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute(
+        """
+        UPDATE workflows
+        SET description = 'Resume all workflows that are stuck on tasks with the status ''waiting'', ''created'' or ''resumed'''
+        WHERE name = 'task_resume_workflows';
+    """
+    )
+
+
+def downgrade() -> None:
+    op.execute(
+        """
+        UPDATE workflows
+        SET description = 'Resume all workflows that are stuck on tasks with the status ''waiting'''
+        WHERE name = 'task_resume_workflows';
+    """
+    )

{orchestrator_core-4.2.0rc3/orchestrator/services → orchestrator_core-4.3.0/orchestrator/services/executors}/celery.py

@@ -18,19 +18,22 @@ from uuid import UUID
 import structlog
 from celery.result import AsyncResult
 from kombu.exceptions import ConnectionError, OperationalError
+from sqlalchemy import select
 
-from oauth2_lib.fastapi import OIDCUserModel
 from orchestrator import app_settings
 from orchestrator.api.error_handling import raise_status
 from orchestrator.db import ProcessTable, db
-from orchestrator.services.input_state import store_input_state
-from orchestrator.services.processes import create_process, delete_process
+from orchestrator.services.processes import (
+    SYSTEM_USER,
+    can_be_resumed,
+    create_process,
+    delete_process,
+    set_process_status,
+)
 from orchestrator.services.workflows import get_workflow_by_name
-from orchestrator.workflows import get_workflow
+from orchestrator.workflow import ProcessStat, ProcessStatus
 from pydantic_forms.types import State
 
-SYSTEM_USER = "SYSTEM"
-
 logger = structlog.get_logger(__name__)
 
 
@@ -42,29 +45,17 @@ def _block_when_testing(task_result: AsyncResult) -> None:
             raise RuntimeError("Celery worker has failed to resume process")
 
 
-def _celery_start_process(
-    workflow_key: str,
-    user_inputs: list[State] | None,
-    user: str = SYSTEM_USER,
-    user_model: OIDCUserModel | None = None,
-    **kwargs: Any,
-) -> UUID:
+def _celery_start_process(pstat: ProcessStat, user: str = SYSTEM_USER, **kwargs: Any) -> UUID:
     """Client side call of Celery."""
     from orchestrator.services.tasks import NEW_TASK, NEW_WORKFLOW, get_celery_task
 
-    workflow = get_workflow(workflow_key)
-    if not workflow:
-        raise_status(HTTPStatus.NOT_FOUND, "Workflow does not exist")
-
-    wf_table = get_workflow_by_name(workflow.name)
-    if not wf_table:
+    if not (wf_table := get_workflow_by_name(pstat.workflow.name)):
         raise_status(HTTPStatus.NOT_FOUND, "Workflow in Database does not exist")
 
     task_name = NEW_TASK if wf_table.is_task else NEW_WORKFLOW
     trigger_task = get_celery_task(task_name)
-    pstat = create_process(workflow_key, user_inputs=user_inputs, user=user, user_model=user_model)
     try:
-        result = trigger_task.delay(pstat.process_id, workflow_key, user)
+        result = trigger_task.delay(pstat.process_id, user)
         _block_when_testing(result)
         return pstat.process_id
     except (ConnectionError, OperationalError) as e:
@@ -77,65 +68,62 @@ def _celery_start_process(
 def _celery_resume_process(
     process: ProcessTable,
     *,
-    user_inputs: list[State] | None = None,
     user: str | None = None,
     **kwargs: Any,
-) -> UUID:
+) -> bool:
     """Client side call of Celery."""
-    from orchestrator.services.processes import load_process
     from orchestrator.services.tasks import RESUME_TASK, RESUME_WORKFLOW, get_celery_task
 
-    pstat = load_process(process)
     last_process_status = process.last_status
-    workflow = pstat.workflow
-
-    wf_table = get_workflow_by_name(workflow.name)
-    if not workflow or not wf_table:
-        raise_status(HTTPStatus.NOT_FOUND, "Workflow does not exist")
 
-    task_name = RESUME_TASK if wf_table.is_task else RESUME_WORKFLOW
+    task_name = RESUME_TASK if process.workflow.is_task else RESUME_WORKFLOW
     trigger_task = get_celery_task(task_name)
 
-    user_inputs = user_inputs or [{}]
-    store_input_state(pstat.process_id, user_inputs, "user_input")
+    _celery_set_process_status_resumed(process.process_id)
+
     try:
-        _celery_set_process_status_resumed(process)
-        result = trigger_task.delay(pstat.process_id, user)
+        result = trigger_task.delay(process.process_id, user)
         _block_when_testing(result)
 
-        return pstat.process_id
+        return process.process_id
     except (ConnectionError, OperationalError) as e:
         logger.warning(
             "Connection error when submitting task to celery. Resetting process status back",
             current_status=process.last_status,
             last_status=last_process_status,
         )
-        _celery_set_process_status(process, last_process_status)
+        set_process_status(process.process_id, last_process_status)
         raise e
 
 
-def _celery_set_process_status(process: ProcessTable, status: str) -> None:
-    process.last_status = status
-    db.session.add(process)
-    db.session.commit()
-
+def _celery_set_process_status_resumed(process_id: UUID) -> None:
+    """Set the process status to RESUMED to show its waiting to be picked up by a worker.
 
-def _celery_set_process_status_resumed(process: ProcessTable) -> None:
-    """Set the process status to RESUMED to prevent re-adding to task queue.
+    uses with_for_update to lock the subscription in a transaction, preventing other changes.
+    rolls back transation and raises an exception when it can't change to RESUMED to prevent it from being added to the queue.
 
     Args:
-        process: Process from database
+        process_id: Process ID to fetch process from DB
     """
-    from orchestrator.db import db
-    from orchestrator.workflow import ProcessStatus
+    stmt = select(ProcessTable).where(ProcessTable.process_id == process_id).with_for_update()
+
+    result = db.session.execute(stmt)
+    locked_process = result.scalar_one_or_none()
+
+    if not locked_process:
+        raise ValueError(f"Process not found: {process_id}")
 
-    process.last_status = ProcessStatus.RESUMED
-    db.session.add(process)
-    db.session.commit()
+    if can_be_resumed(locked_process.last_status):
+        locked_process.last_status = ProcessStatus.RESUMED
+        db.session.commit()
+    else:
+        db.session.rollback()
+        raise ValueError(f"Process has incorrect status to resume: {locked_process.last_status}")
 
 
 def _celery_validate(validation_workflow: str, json: list[State] | None) -> None:
-    _celery_start_process(validation_workflow, user_inputs=json)
+    pstat = create_process(validation_workflow, user_inputs=json)
+    _celery_start_process(pstat)
 
 
 CELERY_EXECUTION_CONTEXT: dict[str, Callable] = {

orchestrator_core-4.3.0/orchestrator/services/executors/threadpool.py

@@ -0,0 +1,128 @@
+# Copyright 2019-2025 SURF, GÉANT, ESnet.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections.abc import Callable
+from functools import partial
+from uuid import UUID
+
+import structlog
+from sqlalchemy import select
+
+from oauth2_lib.fastapi import OIDCUserModel
+from orchestrator.db import ProcessTable, db
+from orchestrator.services.input_state import InputType, retrieve_input_state
+from orchestrator.services.processes import (
+    RESUME_WORKFLOW_REMOVED_ERROR_MSG,
+    START_WORKFLOW_REMOVED_ERROR_MSG,
+    SYSTEM_USER,
+    StateMerger,
+    _run_process_async,
+    create_process,
+    load_process,
+    safe_logstep,
+)
+from orchestrator.types import BroadcastFunc
+from orchestrator.workflow import (
+    ProcessStat,
+    ProcessStatus,
+    runwf,
+)
+from orchestrator.workflows.removed_workflow import removed_workflow
+from pydantic_forms.types import State
+
+logger = structlog.get_logger(__name__)
+
+
+def _set_process_status_running(process_id: UUID) -> None:
+    """Set the process status to RUNNING to prevent it from being picked up by mutliple workers.
+
+    uses with_for_update to lock the subscription in a transaction, preventing other changes.
+    rolls back transation and raises an exception when its already on status RUNNING to prevent worker from running an already running process
+
+    Args:
+        process_id: Process ID to fetch process from DB
+    """
+    stmt = select(ProcessTable).where(ProcessTable.process_id == process_id).with_for_update()
+
+    result = db.session.execute(stmt)
+    locked_process = result.scalar_one_or_none()
+
+    if not locked_process:
+        db.session.rollback()
+        raise ValueError(f"Process not found: {process_id}")
+
+    if locked_process.last_status is not ProcessStatus.RUNNING:
+        locked_process.last_status = ProcessStatus.RUNNING
+        db.session.commit()
+    else:
+        db.session.rollback()
+        raise Exception("Process is already running")
+
+
+def thread_start_process(
+    pstat: ProcessStat,
+    user: str = SYSTEM_USER,
+    user_model: OIDCUserModel | None = None,
+    broadcast_func: BroadcastFunc | None = None,
+) -> UUID:
+    if pstat.workflow == removed_workflow:
+        raise ValueError(START_WORKFLOW_REMOVED_ERROR_MSG)
+
+    # enforce an update to the process status to properly show the process
+    _set_process_status_running(pstat.process_id)
+
+    input_data = retrieve_input_state(pstat.process_id, "initial_state", False)
+    pstat.update(state=pstat.state.map(lambda state: StateMerger.merge(state, input_data.input_state)))
+
+    _safe_logstep_with_func = partial(safe_logstep, broadcast_func=broadcast_func)
+    return _run_process_async(pstat.process_id, lambda: runwf(pstat, _safe_logstep_with_func))
+
+
+def thread_resume_process(
+    process: ProcessTable,
+    *,
+    user: str | None = None,
+    user_model: OIDCUserModel | None = None,
+    broadcast_func: BroadcastFunc | None = None,
+) -> UUID:
+    # ATTENTION!! When modifying this function make sure you make similar changes to `resume_workflow` in the test code
+    pstat = load_process(process)
+    if pstat.workflow == removed_workflow:
+        raise ValueError(RESUME_WORKFLOW_REMOVED_ERROR_MSG)
+
+    if user:
+        pstat.update(current_user=user)
+
+    # retrieve_input_str is for the edge case when workflow engine stops whilst there is an existing 'CREATED' process queue'ed.
+    # It will have become a `RUNNING` process that gets resumed and this should fetch initial_state instead of user_input.
+    retrieve_input_str: InputType = "user_input" if process.steps else "initial_state"
+    input_data = retrieve_input_state(process.process_id, retrieve_input_str, False)
+    pstat.update(state=pstat.state.map(lambda state: StateMerger.merge(state, input_data.input_state)))
+
+    # enforce an update to the process status to properly show the process
+    _set_process_status_running(process.process_id)
+
+    _safe_logstep_prep = partial(safe_logstep, broadcast_func=broadcast_func)
+    _run_process_async(pstat.process_id, lambda: runwf(pstat, _safe_logstep_prep))
+    return pstat.process_id
+
+
+def thread_validate_workflow(validation_workflow: str, json: list[State] | None) -> UUID:
+    pstat = create_process(validation_workflow, user_inputs=json)
+    return thread_start_process(pstat)
+
+
+THREADPOOL_EXECUTION_CONTEXT: dict[str, Callable] = {
+    "start": thread_start_process,
+    "resume": thread_resume_process,
+    "validate": thread_validate_workflow,
+}

{orchestrator_core-4.2.0rc3 → orchestrator_core-4.3.0}/orchestrator/services/input_state.py

@@ -24,12 +24,13 @@ logger = structlog.get_logger(__name__)
 InputType = Literal["initial_state", "user_input"]
 
 
-def retrieve_input_state(process_id: UUID, input_type: InputType) -> InputStateTable:
+def retrieve_input_state(process_id: UUID, input_type: InputType, raise_exception: bool = True) -> InputStateTable:
     """Get user input.
 
     Args:
         process_id: Process ID
         input_type: The type of the input.
+        raise_exception: boolean to throw error when not finding data or not
 
     Returns:
         User input table
@@ -40,13 +41,15 @@ def retrieve_input_state(process_id: UUID, input_type: InputType) -> InputStateT
         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:
         logger.debug("Retrieved input state", process_id=process_id, input_state=res, input_type=input_type)
         return res
-    raise ValueError(f"No input state for pid: {process_id}")
+    if raise_exception:
+        raise ValueError(f"No input state for pid: {process_id}")
+    return InputStateTable(input_state={})
 
 
 def store_input_state(

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

@@ -51,7 +51,6 @@ from orchestrator.workflow import (
     Success,
     Workflow,
     abort_wf,
-    runwf,
 )
 from orchestrator.workflow import Process as WFProcess
 from orchestrator.workflows import get_workflow
@@ -68,13 +67,18 @@ SYSTEM_USER = "SYSTEM"
 
 _workflow_executor = None
 
+START_WORKFLOW_REMOVED_ERROR_MSG = "This workflow cannot be started because it has been removed"
+RESUME_WORKFLOW_REMOVED_ERROR_MSG = "This workflow cannot be resumed because it has been removed"
+
 
 def get_execution_context() -> dict[str, Callable]:
     if app_settings.EXECUTOR == ExecutorType.WORKER:
-        from orchestrator.services.celery import CELERY_EXECUTION_CONTEXT
+        from orchestrator.services.executors.celery import CELERY_EXECUTION_CONTEXT
 
         return CELERY_EXECUTION_CONTEXT
 
+    from orchestrator.services.executors.threadpool import THREADPOOL_EXECUTION_CONTEXT
+
     return THREADPOOL_EXECUTION_CONTEXT
 
 
@@ -449,7 +453,6 @@ def create_process(
     }
 
     try:
-
         state = post_form(workflow.initial_input_form, initial_state, user_inputs)
     except FormValidationError:
         logger.exception("Validation errors", user_inputs=user_inputs)
@@ -469,19 +472,6 @@ def create_process(
     return pstat
 
 
-def thread_start_process(
-    workflow_key: str,
-    user_inputs: list[State] | None = None,
-    user: str = SYSTEM_USER,
-    user_model: OIDCUserModel | None = None,
-    broadcast_func: BroadcastFunc | None = None,
-) -> UUID:
-    pstat = create_process(workflow_key, user_inputs=user_inputs, user=user, user_model=user_model)
-
-    _safe_logstep_with_func = partial(safe_logstep, broadcast_func=broadcast_func)
-    return _run_process_async(pstat.process_id, lambda: runwf(pstat, _safe_logstep_with_func))
-
-
 def start_process(
     workflow_key: str,
     user_inputs: list[State] | None = None,
@@ -502,57 +492,47 @@ def start_process(
         process id
 
     """
+    pstat = create_process(workflow_key, user_inputs=user_inputs, user=user)
+
     start_func = get_execution_context()["start"]
-    return start_func(
-        workflow_key, user_inputs=user_inputs, user=user, user_model=user_model, broadcast_func=broadcast_func
-    )
+    return start_func(pstat, user=user, user_model=user_model, broadcast_func=broadcast_func)
 
 
-def thread_resume_process(
+def restart_process(
     process: ProcessTable,
     *,
-    user_inputs: list[State] | None = None,
     user: str | None = None,
     broadcast_func: BroadcastFunc | None = None,
 ) -> UUID:
-    # ATTENTION!! When modifying this function make sure you make similar changes to `resume_workflow` in the test code
-
-    if user_inputs is None:
-        user_inputs = [{}]
-
-    pstat = load_process(process)
-
-    if pstat.workflow == removed_workflow:
-        raise ValueError("This workflow cannot be resumed")
+    """Restart a process that is stuck on status CREATED.
 
-    form = pstat.log[0].form
-
-    user_input = post_form(form, pstat.state.unwrap(), user_inputs)
+    Args:
+        process: Process from database
+        user: user who resumed this process
+        broadcast_func: Optional function to broadcast process data
 
-    if user:
-        pstat.update(current_user=user)
+    Returns:
+        process id
 
-    if user_input:
-        pstat.update(state=pstat.state.map(lambda state: StateMerger.merge(state, user_input)))
-    store_input_state(pstat.process_id, user_input, "user_input")
-    # enforce an update to the process status to properly show the process
-    process.last_status = ProcessStatus.RUNNING
-    db.session.add(process)
-    db.session.commit()
+    """
+    pstat = load_process(process)
 
-    _safe_logstep_prep = partial(safe_logstep, broadcast_func=broadcast_func)
-    return _run_process_async(pstat.process_id, lambda: runwf(pstat, _safe_logstep_prep))
+    start_func = get_execution_context()["start"]
+    return start_func(pstat, user=user, broadcast_func=broadcast_func)
 
 
-def thread_validate_workflow(validation_workflow: str, json: list[State] | None) -> UUID:
-    return thread_start_process(validation_workflow, user_inputs=json)
+RESUMABLE_STATUSES = (
+    ProcessStatus.SUSPENDED,  # Can be resumed
+    ProcessStatus.WAITING,  # Can be retried
+    ProcessStatus.FAILED,  # Can be retried
+    ProcessStatus.API_UNAVAILABLE,  # subtype of FAILED
+    ProcessStatus.INCONSISTENT_DATA,  # subtype of FAILED
+    ProcessStatus.RESUMED,  # re-resume stuck process
+)
 
 
-THREADPOOL_EXECUTION_CONTEXT: dict[str, Callable] = {
-    "start": thread_start_process,
-    "resume": thread_resume_process,
-    "validate": thread_validate_workflow,
-}
+def can_be_resumed(status: ProcessStatus) -> bool:
+    return status in RESUMABLE_STATUSES
 
 
 def resume_process(
@@ -576,14 +556,19 @@ def resume_process(
     """
     pstat = load_process(process)
 
+    if pstat.workflow == removed_workflow:
+        raise ValueError(RESUME_WORKFLOW_REMOVED_ERROR_MSG)
+
     try:
-        post_form(pstat.log[0].form, pstat.state.unwrap(), user_inputs=user_inputs or [])
+        user_input = post_form(pstat.log[0].form, pstat.state.unwrap(), user_inputs=user_inputs or [{}])
     except FormValidationError:
         logger.exception("Validation errors", user_inputs=user_inputs)
         raise
 
+    store_input_state(pstat.process_id, user_input, "user_input")
+
     resume_func = get_execution_context()["resume"]
-    return resume_func(process, user_inputs=user_inputs, user=user, broadcast_func=broadcast_func)
+    return resume_func(process, user=user, broadcast_func=broadcast_func)
 
 
 def ensure_correct_callback_token(pstat: ProcessStat, *, token: str) -> None:
@@ -809,6 +794,12 @@ def _get_running_processes() -> list[ProcessTable]:
     return list(db.session.scalars(stmt))
 
 
+def set_process_status(process: ProcessTable, status: ProcessStatus) -> None:
+    process.last_status = status
+    db.session.add(process)
+    db.session.commit()
+
+
 def marshall_processes(engine_settings: EngineSettingsTable, new_global_lock: bool) -> EngineSettingsTable | None:
     """Manage processes depending on the engine status.
 
@@ -831,6 +822,7 @@ def marshall_processes(engine_settings: EngineSettingsTable, new_global_lock: bo
 
             # Resume all the running processes
             for process in _get_running_processes():
+                set_process_status(process, ProcessStatus.RESUMED)
                 resume_process(process, user=SYSTEM_USER)
 
         elif not engine_settings.global_lock and new_global_lock: