orchestrator-core 4.0.4__tar.gz → 4.1.0__tar.gz

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/.bumpversion.cfg

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

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.0.4
+Version: 4.1.0
 Summary: This is the orchestrator workflow engine.
 Requires-Python: >=3.11,<3.14
 Classifier: Intended Audience :: Information Technology
@@ -39,7 +39,7 @@ Requires-Dist: more-itertools~=10.7.0
 Requires-Dist: itsdangerous
 Requires-Dist: Jinja2==3.1.6
 Requires-Dist: orjson==3.10.18
-Requires-Dist: prometheus-client==0.22.0
+Requires-Dist: prometheus-client==0.22.1
 Requires-Dist: psycopg2-binary==2.9.10
 Requires-Dist: pydantic[email]~=2.8.2
 Requires-Dist: pydantic-settings~=2.9.1
@@ -84,7 +84,7 @@ Requires-Dist: dirty-equals ; extra == "test"
 Requires-Dist: jsonref ; extra == "test"
 Requires-Dist: mypy==1.9 ; extra == "test"
 Requires-Dist: pyinstrument ; extra == "test"
-Requires-Dist: pytest==8.3.5 ; extra == "test"
+Requires-Dist: pytest==8.4.1 ; extra == "test"
 Requires-Dist: pytest-asyncio==0.21.2 ; extra == "test"
 Requires-Dist: pytest-codspeed ; extra == "test"
 Requires-Dist: pytest-cov ; extra == "test"

orchestrator_core-4.1.0/docs/reference-docs/app/settings_overview.md

@@ -0,0 +1,89 @@
+# Settings overview in Orchestrator
+
+You can use the `api/settings/overview` endpoint to get an overview of the settings that are used in the application.
+This endpoint provides a JSON response that contains the settings that are defined in the application. The settings are
+grouped by their names and sensitive values are masked for security reasons.
+Per default, the application settings are used to configure the application. The settings are defined in the
+`orchestrator.settings.py` module and can be used to configure the application.
+
+An example of the settings is shown below:
+
+```python
+from orchestrator.settings import BaseSettings
+
+
+class AppSettings(BaseSettings):
+    TESTING: bool = True
+    SESSION_SECRET: OrchSecretStr = "".join(secrets.choice(string.ascii_letters) for i in range(16))  # type: ignore
+    CORS_ORIGINS: str = "*"
+    ...
+    EXPOSE_SETTINGS: bool = False
+    EXPOSE_OAUTH_SETTINGS: bool = False
+
+
+app_settings = AppSettings()
+
+if app_settings.EXPOSE_SETTINGS:
+    expose_settings("app_settings", app_settings)  # type: ignore
+
+if app_settings.EXPOSE_OAUTH_SETTINGS:
+    expose_settings("oauth2lib_settings", oauth2lib_settings)  # type: ignore
+```
+
+What you see above is the default settings for the application. The settings are defined in the
+`orchestrator.settings.py` module and can be used to configure the application.
+The `EXPOSE_SETTINGS` and `EXPOSE_OAUTH_SETTINGS` flags are used to control whether the settings should be exposed via
+the `api/settings/overview` endpoint, the result looks like this:
+
+```json
+[
+  {
+    "name": "app_settings",
+    "variables": [
+      {
+        "env_name": "TESTING",
+        "env_value": false
+      },
+      {
+        "env_name": "SESSION_SECRET",
+        "env_value": "**********"
+      },
+      {
+        "env_name": "CORS_ORIGINS",
+        "env_value": "*"
+      }
+    ]
+  }
+]
+```
+
+The `app_settings` in the example above is a name of the settings class that is registered to be exposed.
+
+## Exposing your settings
+
+In order to expose your settings, you need to register them using the `expose_settings()` function. This function takes
+two arguments: the name of the settings class and the instance of the settings class.
+
+```python
+from orchestrator.settings import expose_settings, BaseSettings
+
+
+class MySettings(BaseSettings):
+    debug: bool = True
+
+
+my_settings = MySettings()
+
+expose_settings("my_settings", my_settings)
+```
+
+## Masking Secrets
+
+The following rules apply when exposing settings:
+
+### Rules for Masking Secrets
+
+- Keys containing `"password"` or `"secret"` in their names are masked.
+- `SecretStr` from `from pydantic import SecretStr` are masked.
+- `SecretStr` from `from orchestrator.utils.expose_settings import SecretStr` are masked.
+- `PostgresDsn` from `from pydantic import PostgresDsn` are masked.

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/docs/reference-docs/auth-backend-and-frontend.md

@@ -269,6 +269,323 @@ app.register_authorization(authorization_instance)
 app.register_graphql_authorization(graphql_authorization_instance)
 ```
 
+## Authorization and Workflows
+
+!!! Warning
+    Role-based access control for workflows is currently in beta.
+    Initial support has been added to the backend, but the feature is not fully communicated through the UI yet.
+
+Certain `orchestrator-core` decorators accept authorization callbacks of type `type Authorizer = Callable[OIDCUserModel, bool]`, which return True when the input user is authorized, otherwise False.
+
+A table (below) is available for comparing possible configuration states with the policy that will be enforced.
+
+### `@workflow`
+The `@workflow` decorator accepts the optional parameters `auth: Authorizer` and `retry_auth: Authorizer`.
+
+`auth` will be used to determine the authorization of a user to start the workflow.
+If `auth` is omitted, the workflow is authorized for any logged in user.
+
+`retry_auth` will be used to determine the authorization of a user to start, resume, or retry the workflow from a failed step.
+If `retry_auth` is omitted, then `auth` is used to authorize.
+
+(This does not percolate past an `@inputstep` that specifies `resume_auth` or `retry_auth`.)
+
+Examples:
+
+* `auth=None, retry_auth=None`: any user may run the workflow.
+* `auth=A, retry_auth=B`: users authorized by A may start the workflow. Users authorized by B may retry on failure.
+    * Example: starting the workflow is a decision that must be made by a product owner. Retrying can be made by an on-call member of the operations team.
+* `auth=None, retry_auth=B`: any user can start the workflow, but only users authorized by B may retry on failure.
+
+### `@inputstep`
+The `@inputstep` decorator accepts the optional parameters `resume_auth: Authorizer` and `retry_auth: Authorizer`.
+
+`resume_auth` will be used to determine the authorization of a user to resume the workflow when suspended at this inputstep.
+If `resume_auth` is omitted, then the workflow's `auth` will be used.
+
+`retry_auth` will be used to determine the authorization of a user to retry the workflow from a failed step following the inputstep.
+If `retry_auth` is omitted, then `resume_auth` is used to authorize retries.
+If `resume_auth` is also omitted, then the workflow’s `retry_auth` is checked, and then the workflow’s `auth`.
+
+In summary:
+
+* A workflow establishes `auth` for starting, resuming, or retrying.
+* The workflow can also establish `retry_auth`, which will override `auth` for retries.
+    * An inputstep can override the existing `auth` with `resume_auth` and the existing `retry_auth` with its own `retry_auth`.
+* Subsequent inputsteps can do the same, but any None will not overwrite a previous not-None.
+
+### Policy resolutions
+Below is an exhaustive table of how policies (implemented as callbacks `A`, `B`, `C`, and `D`)
+are prioritized in different workflow and inputstep configurations.
+
+<table>
+  <thead>
+    <tr>
+      <th colspan=4>Configuration</th>
+      <th colspan=4>Enforcement</th>
+      <th>Notes</th>
+    </tr>
+    <tr>
+      <th colspan=2>@workflow</th>
+      <th colspan=2>@inputstep</th>
+      <th colspan=2>before @inputstep</th>
+      <th colspan=2>@inputstep and after</th>
+      <th></th>
+    </tr>
+    <tr>
+      <th>auth</th>
+      <th>retry_auth</th>
+      <th>resume_auth</th>
+      <th>retry_auth</th>
+      <th>start</th>
+      <th>retry</th>
+      <th>resume</th>
+      <th>retry</th>
+      <th></th>
+    </tr>
+  </thead>
+  <tbody>
+      <tr>
+        <td>None</td>
+        <td>None</td>
+        <td>None</td>
+        <td>None</td>
+        <td>Anyone</td>
+        <td>Anyone</td>
+        <td>Anyone</td>
+        <td>Anyone</td>
+        <td>Default</td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>None</td>
+        <td>None</td>
+        <td>None</td>
+        <td>A</td>
+        <td>A</td>
+        <td>A</td>
+        <td>A</td>
+        <td>Broadly restrict the workflow to a specific authorizer.</td>
+      </tr>
+      <tr>
+        <td>None</td>
+        <td>B</td>
+        <td>None</td>
+        <td>None</td>
+        <td>Anyone</td>
+        <td>B</td>
+        <td>Anyone</td>
+        <td>B</td>
+        <td>original retry_auth is maintained if nothing supercedes it. Weird choice, but this provides a "we specifically want to limit retries" route.</td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>B</td>
+        <td>None</td>
+        <td>None</td>
+        <td>A</td>
+        <td>B</td>
+        <td>A</td>
+        <td>B</td>
+        <td>Workflow-level auth and retry. Allows A or B to be tighter or distinct, as needed.</td>
+      </tr>
+      <tr>
+        <td>None</td>
+        <td>None</td>
+        <td>C</td>
+        <td>None</td>
+        <td>Anyone</td>
+        <td>Anyone</td>
+        <td>C</td>
+        <td>C</td>
+        <td>Anyone can start this workflow, but only C can continue it.</td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>None</td>
+        <td>C</td>
+        <td>None</td>
+        <td>A</td>
+        <td>A</td>
+        <td>C</td>
+        <td>C</td>
+        <td>Subsequent retries use C, not A! Override with retry_auth=A if desired.</td>
+      </tr>
+      <tr>
+        <td>None</td>
+        <td>B</td>
+        <td>C</td>
+        <td>None</td>
+        <td>Anyone</td>
+        <td>B</td>
+        <td>C</td>
+        <td>C</td>
+        <td>Subsequent retries use C, not B! Override with retry_auth=B if desired.</td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>B</td>
+        <td>C</td>
+        <td>None</td>
+        <td>A</td>
+        <td>B</td>
+        <td>C</td>
+        <td>C</td>
+        <td>Simple override initial settings with inputstep resume_auth.</td>
+      </tr>
+      <tr>
+        <td>None</td>
+        <td>None</td>
+        <td>None</td>
+        <td>D</td>
+        <td>Anyone</td>
+        <td>Anyone</td>
+        <td>Anyone</td>
+        <td>D</td>
+        <td>Anyone can start or retry or resume, but limit retries to D once inputstep is reached.</td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>None</td>
+        <td>None</td>
+        <td>D</td>
+        <td>A</td>
+        <td>A</td>
+        <td>A</td>
+        <td>D</td>
+        <td>A can start or retry or resume, but limit retries to D once inputstep is reached.</td>
+      </tr>
+      <tr>
+        <td>None</td>
+        <td>B</td>
+        <td>None</td>
+        <td>D</td>
+        <td>Anyone</td>
+        <td>B</td>
+        <td>Anyone</td>
+        <td>D</td>
+        <td>Anyone can start or resume, but only B can retry. After inputstep, only D can retry.</td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>B</td>
+        <td>None</td>
+        <td>D</td>
+        <td>A</td>
+        <td>B</td>
+        <td>A</td>
+        <td>D</td>
+        <td>A can start or resume, but only B can retry. After inputstep, only D can retry.</td>
+      </tr>
+      <tr>
+        <td>None</td>
+        <td>None</td>
+        <td>C</td>
+        <td>D</td>
+        <td>Anyone</td>
+        <td>Anyone</td>
+        <td>C</td>
+        <td>D</td>
+        <td>Anyone can start, but only C can resume and only D can retry after the resume.</td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>None</td>
+        <td>C</td>
+        <td>D</td>
+        <td>A</td>
+        <td>A</td>
+        <td>C</td>
+        <td>D</td>
+        <td></td>
+      </tr>
+      <tr>
+        <td>None</td>
+        <td>B</td>
+        <td>C</td>
+        <td>D</td>
+        <td>Anyone</td>
+        <td>B</td>
+        <td>C</td>
+        <td>D</td>
+        <td></td>
+      </tr>
+      <tr>
+        <td>A</td>
+        <td>B</td>
+        <td>C</td>
+        <td>D</td>
+        <td>A</td>
+        <td>B</td>
+        <td>C</td>
+        <td>D</td>
+        <td></td>
+      </tr>
+  </tbody>
+</table>
+
+### Examples
+Assume we have the following function that can be used to create callbacks:
+
+```python
+def allow_roles(*roles) -> Callable[OIDCUserModel|None, bool]:
+    def f(user: OIDCUserModel) -> bool:
+        if is_admin(user):  # Relative to your authorization provider
+            return True
+        for role in roles:
+            if has_role(user, role):  # Relative to your authorization provider
+                return True
+        return False
+
+    return f
+```
+
+We can now construct a variety of authorization policies.
+
+#### Rubber Stamp Model
+!!!example
+    Suppose we have a workflow W that needs to pause on inputstep `approval` for approval from finance. Ops (and only ops) should be able to start the workflow and retry any failed steps. Finance (and only finance) should be able to resume at the input step.
+
+    ```python
+    @workflow("An expensive workflow", auth=allow_roles("ops"))
+    def W(...):
+        return begin >> A >> ... >> notify_finance >> approval >> ... >> Z
+
+    @inputstep("Approval", resume_auth=allow_roles("finance"), retry_auth=allow_roles("ops"))
+    def approval(...):
+        ...
+    ```
+
+
+#### Hand-off Model
+!!!example
+    Suppose we have two teams, Dev and Platform, and a long workflow W that should be handed off to Platform at step `approval`.
+
+    Dev can start the workflow and retry steps prior to S. Once step S is reached, Platform (and only Platform) can resume the workflow and retry later failed steps.
+
+    ```python
+    @workflow("An expensive workflow", auth=allow_roles("dev"))
+    def W(...):
+        return begin >> A >> ... >> notify_platform >> handoff >> ... >> Z
+
+    @inputstep("Hand-off", resume_auth=allow_roles("platform"))
+    def handoff(...):
+        ...
+    ```
+    Notice that default behaviors let us ignore `retry_auth` arguments in both decorators.
+
+#### Restricted Retries Model
+!!!example
+    Suppose we have a workflow that anyone can run, but with steps that should only be retried by users with certain backend access.
+
+    ```python
+    @workflow("A workflow for any user", retry_auth=allow_roles("admin"))
+    def W(...):
+        return begin >> A >> ... >> S >> ... >> Z
+    ```
+
+    Note that we could specify `auth=allow_roles("user")` if helpful, or we can omit `auth` to fail open to any logged in user.
+
 [1]: https://github.com/workfloworchestrator/example-orchestrator-ui
 [2]: https://github.com/workfloworchestrator/example-orchestrator
 [3]: https://next-auth.js.org/

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/docs/reference-docs/cli.md

@@ -35,7 +35,6 @@ Interact with the application database. By default, does nothing, specify `main.
         - migrate_tasks
         - revision
         - upgrade
-
       heading_level: 3
 
 ### migrate-domain-models

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/mkdocs.yml

@@ -182,6 +182,7 @@ nav:
                 - App.py: reference-docs/app/app.md
                 - Python Version: reference-docs/python.md
                 - Scaling: reference-docs/app/scaling.md
+                - Settings: reference-docs/app/settings_overview.md
           # - Tasks:  reference-docs/tasks.md
           # - Tests: reference-docs/tests.md
           - Workflows:

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/orchestrator/__init__.py

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

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/orchestrator/api/api_v1/endpoints/processes.py

@@ -25,7 +25,7 @@ from fastapi.param_functions import Body, Depends, Header
 from fastapi.routing import APIRouter
 from fastapi.websockets import WebSocket
 from fastapi_etag.dependency import CacheHit
-from more_itertools import chunked
+from more_itertools import chunked, last
 from sentry_sdk.tracing import trace
 from sqlalchemy import CompoundSelect, Select, select
 from sqlalchemy.orm import defer, joinedload
@@ -56,6 +56,7 @@ from orchestrator.services.processes import (
 )
 from orchestrator.services.settings import get_engine_settings
 from orchestrator.settings import app_settings
+from orchestrator.utils.auth import Authorizer
 from orchestrator.utils.enrich_process import enrich_process
 from orchestrator.websocket import (
     WS_CHANNELS,
@@ -63,7 +64,7 @@ from orchestrator.websocket import (
     broadcast_process_update_to_websocket,
     websocket_manager,
 )
-from orchestrator.workflow import ProcessStatus
+from orchestrator.workflow import ProcessStat, ProcessStatus, StepList, Workflow
 from pydantic_forms.types import JSON, State
 
 router = APIRouter()
@@ -86,6 +87,48 @@ def check_global_lock() -> None:
         )
 
 
+def get_current_steps(pstat: ProcessStat) -> StepList:
+    """Extract past and current steps from the ProcessStat."""
+    remaining_steps = pstat.log
+    past_steps = pstat.workflow.steps[: -len(remaining_steps)]
+    return StepList(past_steps + [pstat.log[0]])
+
+
+def get_auth_callbacks(steps: StepList, workflow: Workflow) -> tuple[Authorizer | None, Authorizer | None]:
+    """Iterate over workflow and prior steps to determine correct authorization callbacks for the current step.
+
+    It's safest to always iterate through the steps. We could track these callbacks statefully
+    as we progress through the workflow, but if we fail a step and the system restarts, the previous
+    callbacks will be lost if they're only available in the process state.
+
+    Priority:
+    - RESUME callback is explicit RESUME callback, else previous START/RESUME callback
+    - RETRY callback is explicit RETRY, else explicit RESUME, else previous RETRY
+    """
+    # Default to workflow start callbacks
+    auth_resume = workflow.authorize_callback
+    # auth_retry defaults to the workflow start callback if not otherwise specified.
+    # A workflow SHOULD have both callbacks set to not-None. This enforces the correct default regardless.
+    auth_retry = workflow.retry_auth_callback or auth_resume  # type: ignore[unreachable, truthy-function]
+
+    # Choose the most recently established value for resume.
+    auth_resume = last(filter(None, (step.resume_auth_callback for step in steps)), auth_resume)
+    # Choose the most recently established value for retry, unless there is a more recent value for resume.
+    auth_retry = last(
+        filter(None, (step.retry_auth_callback or step.resume_auth_callback for step in steps)), auth_retry
+    )
+    return auth_resume, auth_retry
+
+
+def can_be_resumed(status: ProcessStatus) -> bool:
+    return status in (
+        ProcessStatus.SUSPENDED,  # Can be resumed
+        ProcessStatus.FAILED,  # Can be retried
+        ProcessStatus.API_UNAVAILABLE,  # subtype of FAILED
+        ProcessStatus.INCONSISTENT_DATA,  # subtype of FAILED
+    )
+
+
 def resolve_user_name(
     *,
     reporter: Reporter | None,
@@ -150,18 +193,25 @@ def new_process(
     dependencies=[Depends(check_global_lock, use_cache=False)],
 )
 def resume_process_endpoint(
-    process_id: UUID, request: Request, json_data: JSON = Body(...), user: str = Depends(user_name)
+    process_id: UUID,
+    request: Request,
+    json_data: JSON = Body(...),
+    user: str = Depends(user_name),
+    user_model: OIDCUserModel | None = Depends(authenticate),
 ) -> None:
     process = _get_process(process_id)
 
-    if process.last_status == ProcessStatus.COMPLETED:
-        raise_status(HTTPStatus.CONFLICT, "Resuming a completed workflow is not possible")
-
-    if process.last_status == ProcessStatus.RUNNING:
-        raise_status(HTTPStatus.CONFLICT, "Resuming a running workflow is not possible")
-
-    if process.last_status == ProcessStatus.RESUMED:
-        raise_status(HTTPStatus.CONFLICT, "Resuming a resumed workflow is not possible")
+    if not can_be_resumed(process.last_status):
+        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)
+    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")
+    elif process.last_status == ProcessStatus.FAILED:
+        if auth_retry is not None and not auth_retry(user_model):
+            raise_status(HTTPStatus.FORBIDDEN, "User is not authorized to retry step")
 
     broadcast_invalidate_status_counts()
     broadcast_func = api_broadcast_process_data(request)

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/orchestrator/api/api_v1/endpoints/settings.py

@@ -22,11 +22,17 @@ from sqlalchemy.exc import SQLAlchemyError
 from oauth2_lib.fastapi import OIDCUserModel
 from orchestrator.api.error_handling import raise_status
 from orchestrator.db import EngineSettingsTable
-from orchestrator.schemas import EngineSettingsBaseSchema, EngineSettingsSchema, WorkerStatus
+from orchestrator.schemas import (
+    EngineSettingsBaseSchema,
+    EngineSettingsSchema,
+    WorkerStatus,
+)
 from orchestrator.security import authenticate
 from orchestrator.services import processes, settings
 from orchestrator.services.settings import generate_engine_global_status
+from orchestrator.services.settings_env_variables import get_all_exposed_settings
 from orchestrator.settings import ExecutorType, app_settings
+from orchestrator.utils.expose_settings import SettingsExposedSchema
 from orchestrator.utils.json import json_dumps
 from orchestrator.utils.redis import delete_keys_matching_pattern
 from orchestrator.utils.redis_client import create_redis_asyncio_client
@@ -169,3 +175,8 @@ def generate_engine_status_response(
     result = EngineSettingsSchema.model_validate(engine_settings)
     result.global_status = generate_engine_global_status(engine_settings)
     return result
+
+
+@router.get("/overview", response_model=list[SettingsExposedSchema])
+def get_exposed_settings() -> list[SettingsExposedSchema]:
+    return get_all_exposed_settings()

{orchestrator_core-4.0.4 → orchestrator_core-4.1.0}/orchestrator/services/celery.py

@@ -19,6 +19,7 @@ import structlog
 from celery.result import AsyncResult
 from kombu.exceptions import ConnectionError, OperationalError
 
+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
@@ -42,7 +43,11 @@ def _block_when_testing(task_result: AsyncResult) -> None:
 
 
 def _celery_start_process(
-    workflow_key: str, user_inputs: list[State] | None, user: str = SYSTEM_USER, **kwargs: Any
+    workflow_key: str,
+    user_inputs: list[State] | None,
+    user: str = SYSTEM_USER,
+    user_model: OIDCUserModel | None = None,
+    **kwargs: Any,
 ) -> UUID:
     """Client side call of Celery."""
     from orchestrator.services.tasks import NEW_TASK, NEW_WORKFLOW, get_celery_task
@@ -57,7 +62,7 @@ def _celery_start_process(
 
     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)
+    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)
         _block_when_testing(result)