orchestrator-core 3.1.0rc1__py3-none-any.whl → 3.1.2__py3-none-any.whl

orchestrator/services/processes.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# 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
@@ -24,15 +24,10 @@ from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import joinedload
 
 from nwastdlib.ex import show_ex
+from oauth2_lib.fastapi import OIDCUserModel
 from orchestrator.api.error_handling import raise_status
 from orchestrator.config.assignee import Assignee
-from orchestrator.db import (
-    EngineSettingsTable,
-    ProcessStepTable,
-    ProcessSubscriptionTable,
-    ProcessTable,
-    db,
-)
+from orchestrator.db import EngineSettingsTable, ProcessStepTable, ProcessSubscriptionTable, ProcessTable, db
 from orchestrator.distlock import distlock_manager
 from orchestrator.schemas.engine_settings import WorkerStatus
 from orchestrator.services.input_state import store_input_state
@@ -43,9 +38,10 @@ from orchestrator.targets import Target
 from orchestrator.types import BroadcastFunc
 from orchestrator.utils.datetime import nowtz
 from orchestrator.utils.errors import error_state_to_dict
-from orchestrator.websocket import broadcast_invalidate_status_counts
+from orchestrator.websocket import broadcast_invalidate_status_counts, broadcast_process_update_to_websocket
 from orchestrator.workflow import (
     CALLBACK_TOKEN_KEY,
+    DEFAULT_CALLBACK_PROGRESS_KEY,
     Failed,
     ProcessStat,
     ProcessStatus,
@@ -413,10 +409,15 @@ def _run_process_async(process_id: UUID, f: Callable) -> UUID:
     return process_id
 
 
+def error_message_unauthorized(workflow_key: str) -> str:
+    return f"User is not authorized to execute '{workflow_key}' workflow"
+
+
 def create_process(
     workflow_key: str,
     user_inputs: list[State] | None = None,
     user: str = SYSTEM_USER,
+    user_model: OIDCUserModel | None = None,
 ) -> ProcessStat:
     # ATTENTION!! When modifying this function make sure you make similar changes to `run_workflow` in the test code
 
@@ -429,6 +430,9 @@ def create_process(
     if not workflow:
         raise_status(HTTPStatus.NOT_FOUND, "Workflow does not exist")
 
+    if not workflow.authorize_callback(user_model):
+        raise_status(HTTPStatus.FORBIDDEN, error_message_unauthorized(workflow_key))
+
     initial_state = {
         "process_id": process_id,
         "reporter": user,
@@ -448,6 +452,7 @@ def create_process(
         state=Success(state | initial_state),
         log=workflow.steps,
         current_user=user,
+        user_model=user_model,
     )
 
     _db_create_process(pstat)
@@ -459,9 +464,12 @@ 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)
+    if not pstat.workflow.authorize_callback(user_model):
+        raise_status(HTTPStatus.FORBIDDEN, error_message_unauthorized(workflow_key))
 
     _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))
@@ -471,6 +479,7 @@ def 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:
     """Start a process for workflow.
@@ -479,6 +488,7 @@ def start_process(
         workflow_key: name of workflow
         user_inputs: List of form inputs from frontend
         user: User who starts this process
+        user_model: Full OIDCUserModel with claims, etc
         broadcast_func: Optional function to broadcast process data
 
     Returns:
@@ -486,7 +496,9 @@ def start_process(
 
     """
     start_func = get_execution_context()["start"]
-    return start_func(workflow_key, user_inputs=user_inputs, user=user, broadcast_func=broadcast_func)
+    return start_func(
+        workflow_key, user_inputs=user_inputs, user=user, user_model=user_model, broadcast_func=broadcast_func
+    )
 
 
 def thread_resume_process(
@@ -494,6 +506,7 @@ def thread_resume_process(
     *,
     user_inputs: list[State] | None = None,
     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
@@ -502,6 +515,8 @@ def thread_resume_process(
         user_inputs = [{}]
 
     pstat = load_process(process)
+    if not pstat.workflow.authorize_callback(user_model):
+        raise_status(HTTPStatus.FORBIDDEN, error_message_unauthorized(str(process.workflow_name)))
 
     if pstat.workflow == removed_workflow:
         raise ValueError("This workflow cannot be resumed")
@@ -541,6 +556,7 @@ def resume_process(
     *,
     user_inputs: list[State] | None = None,
     user: str | None = None,
+    user_model: OIDCUserModel | None = None,
     broadcast_func: BroadcastFunc | None = None,
 ) -> UUID:
     """Resume a failed or suspended process.
@@ -549,6 +565,7 @@ def resume_process(
         process: Process from database
         user_inputs: Optional user input from forms
         user: user who resumed this process
+        user_model: OIDCUserModel of user who resumed this process
         broadcast_func: Optional function to broadcast process data
 
     Returns:
@@ -556,6 +573,9 @@ def resume_process(
 
     """
     pstat = load_process(process)
+    if not pstat.workflow.authorize_callback(user_model):
+        raise_status(HTTPStatus.FORBIDDEN, error_message_unauthorized(str(process.workflow_name)))
+
     try:
         post_form(pstat.log[0].form, pstat.state.unwrap(), user_inputs=user_inputs or [])
     except FormValidationError:
@@ -566,6 +586,39 @@ def resume_process(
     return resume_func(process, user_inputs=user_inputs, user=user, broadcast_func=broadcast_func)
 
 
+def ensure_correct_callback_token(pstat: ProcessStat, *, token: str) -> None:
+    """Ensure that a callback token matches the expected value in state.
+
+    Args:
+        pstat: ProcessStat of process.
+        token: The token which was generated for the process.
+
+    Raises:
+        AssertionError: if the supplied token does not match the generated process token.
+
+    """
+    state = pstat.state.unwrap()
+
+    # Check if the token matches
+    token_from_state = state.get(CALLBACK_TOKEN_KEY)
+    if token != token_from_state:
+        raise AssertionError("Invalid token")
+
+
+def replace_current_step_state(process: ProcessTable, *, new_state: State) -> None:
+    """Replace the state of the current step in a process.
+
+    Args:
+        process: Process from database
+        new_state: The new state
+
+    """
+    current_step = process.steps[-1]
+    current_step.state = new_state
+    db.session.add(current_step)
+    db.session.commit()
+
+
 def continue_awaiting_process(
     process: ProcessTable,
     *,
@@ -589,10 +642,7 @@ def continue_awaiting_process(
     pstat = load_process(process)
     state = pstat.state.unwrap()
 
-    # Check if the token matches
-    token_from_state = state.get(CALLBACK_TOKEN_KEY)
-    if token != token_from_state:
-        raise AssertionError("Invalid token")
+    ensure_correct_callback_token(pstat, token=token)
 
     # We need to pass the callback data to the worker executor. Currently, this is not supported.
     # Therefore, we update the step state in the db and kick-off resume_workflow
@@ -600,16 +650,47 @@ def continue_awaiting_process(
     result_key = state.get("__callback_result_key", "callback_result")
     state = {**state, result_key: input_data}
 
-    current_step = process.steps[-1]
-    current_step.state = state
-    db.session.add(current_step)
-    db.session.commit()
+    replace_current_step_state(process, new_state=state)
 
     # Continue the workflow
     resume_func = get_execution_context()["resume"]
     return resume_func(process, broadcast_func=broadcast_func)
 
 
+def update_awaiting_process_progress(
+    process: ProcessTable,
+    *,
+    token: str,
+    data: str | State,
+) -> UUID:
+    """Update progress for a process awaiting data from a callback.
+
+    Args:
+        process: Process from database
+        token: The token which was generated for the process. This must match.
+        data: Progress data posted to the callback
+
+    Returns:
+        process id
+
+    Raises:
+        AssertionError: if the supplied token does not match the generated process token.
+
+    """
+    pstat = load_process(process)
+
+    ensure_correct_callback_token(pstat, token=token)
+
+    state = pstat.state.unwrap()
+    progress_key = state.get(DEFAULT_CALLBACK_PROGRESS_KEY, "callback_progress")
+    state = {**state, progress_key: data} | {"__remove_keys": [progress_key]}
+
+    replace_current_step_state(process, new_state=state)
+    broadcast_process_update_to_websocket(process.process_id)
+
+    return process.process_id
+
+
 async def _async_resume_processes(
     processes: Sequence[ProcessTable],
     user_name: str,

orchestrator/services/products.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/services/subscriptions.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/services/tasks.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/settings.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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
@@ -13,7 +13,6 @@
 
 import secrets
 import string
-import warnings
 from pathlib import Path
 from typing import Literal
 
@@ -24,10 +23,6 @@ from oauth2_lib.settings import oauth2lib_settings
 from pydantic_forms.types import strEnum
 
 
-class OrchestratorDeprecationWarning(DeprecationWarning):
-    pass
-
-
 class ExecutorType(strEnum):
     WORKER = "celery"
     THREADPOOL = "threadpool"
@@ -54,7 +49,7 @@ class AppSettings(BaseSettings):
     EXECUTOR: str = ExecutorType.THREADPOOL
     WORKFLOWS_SWAGGER_HOST: str = "localhost"
     WORKFLOWS_GUI_URI: str = "http://localhost:3000"
-    DATABASE_URI: PostgresDsn = "postgresql+psycopg://nwa:nwa@localhost/orchestrator-core"  # type: ignore
+    DATABASE_URI: PostgresDsn = "postgresql://nwa:nwa@localhost/orchestrator-core"  # type: ignore
     MAX_WORKERS: int = 5
     MAIL_SERVER: str = "localhost"
     MAIL_PORT: int = 25
@@ -93,22 +88,6 @@ class AppSettings(BaseSettings):
     VALIDATE_OUT_OF_SYNC_SUBSCRIPTIONS: bool = False
     FILTER_BY_MODE: Literal["partial", "exact"] = "exact"
 
-    def __init__(self) -> None:
-        super(AppSettings, self).__init__()
-        self.DATABASE_URI = PostgresDsn(convert_database_uri(str(self.DATABASE_URI)))
-
-
-def convert_database_uri(db_uri: str) -> str:
-    if db_uri.startswith(("postgresql://", "postgresql+psycopg2://")):
-        db_uri = "postgresql+psycopg" + db_uri[db_uri.find("://") :]
-        warnings.filterwarnings("always", category=OrchestratorDeprecationWarning)
-        warnings.warn(
-            "DATABASE_URI converted to postgresql+psycopg:// format, please update your enviroment variable",
-            OrchestratorDeprecationWarning,
-            stacklevel=2,
-        )
-    return db_uri
-
 
 app_settings = AppSettings()
 

orchestrator/targets.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/types.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/utils/errors.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/utils/state.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF, ESnet
+# Copyright 2019-2020 SURF, ESnet, GÉANT.
 # 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
@@ -150,65 +150,85 @@ def _build_arguments(func: StepFunc | InputStepFunc, state: State) -> list:  # n
 
     Raises:
          KeyError: if requested argument is not in the state, or cannot be reconstructed as an initial domain model.
+         ValueError: if requested argument cannot be converted to the expected type.
 
     """
+
     sig = inspect.signature(func)
+    if not sig.parameters:
+        return []
+
+    def _convert_to_uuid(v: Any) -> UUID:
+        """Converts the value to a UUID instance if it is not already one."""
+        return v if isinstance(v, UUID) else UUID(v)
+
     arguments: list[Any] = []
-    if sig.parameters:
-        for name, param in sig.parameters.items():
-            # Ignore dynamic arguments. Mostly need to deal with `const`
-            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
-                logger.warning("*args and **kwargs are not supported as step params")
-                continue
-
-            # If we find an argument named "state" we use the whole state as argument to
-            # This is mainly to be backward compatible with code that needs the whole state...
-            # TODO: Remove this construction
-            if name == "state":
-                arguments.append(state)
-                continue
-
-            # Workaround for the fact that you can't call issubclass on typing types
+    for name, param in sig.parameters.items():
+        # Ignore dynamic arguments. Mostly need to deal with `const`
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            logger.warning("*args and **kwargs are not supported as step params")
+            continue
+
+        # If we find an argument named "state" we use the whole state as argument to
+        # This is mainly to be backward compatible with code that needs the whole state...
+        # TODO: Remove this construction
+        if name == "state":
+            arguments.append(state)
+            continue
+
+        # Workaround for the fact that you can't call issubclass on typing types
+        try:
+            is_subscription_model_type = issubclass(param.annotation, SubscriptionModel)
+        except Exception:
+            is_subscription_model_type = False
+
+        if is_subscription_model_type:
+            subscription_id = _get_sub_id(state.get(name))
+            if subscription_id:
+                sub_mod = param.annotation.from_subscription(subscription_id)
+                arguments.append(sub_mod)
+            else:
+                logger.error("Could not find key in state.", key=name, state=state)
+                raise KeyError(f"Could not find key '{name}' in state.")
+        elif is_list_type(param.annotation, SubscriptionModel):
+            subscription_ids = [_get_sub_id(item) for item in state.get(name, [])]
+            # Actual type is first argument from list type
+            if (actual_type := get_args(param.annotation)[0]) == Any:
+                raise ValueError(
+                    f"Step function argument '{param.name}' cannot be serialized from database with type 'Any'"
+                )
+            subscriptions = [actual_type.from_subscription(subscription_id) for subscription_id in subscription_ids]
+            arguments.append(subscriptions)
+        elif is_optional_type(param.annotation, SubscriptionModel):
+            subscription_id = _get_sub_id(state.get(name))
+            if subscription_id:
+                # Actual type is first argument from optional type
+                sub_mod = get_args(param.annotation)[0].from_subscription(subscription_id)
+                arguments.append(sub_mod)
+            else:
+                arguments.append(None)
+        elif param.default is not inspect.Parameter.empty:
+            arguments.append(state.get(name, param.default))
+        else:
             try:
-                is_subscription_model_type = issubclass(param.annotation, SubscriptionModel)
-            except Exception:
-                is_subscription_model_type = False
-
-            if is_subscription_model_type:
-                subscription_id = _get_sub_id(state.get(name))
-                if subscription_id:
-                    sub_mod = param.annotation.from_subscription(subscription_id)
-                    arguments.append(sub_mod)
-                else:
-                    logger.error("Could not find key in state.", key=name, state=state)
-                    raise KeyError(f"Could not find key '{name}' in state.")
-            elif is_list_type(param.annotation, SubscriptionModel):
-                subscription_ids = map(_get_sub_id, state.get(name, []))
-                # Actual type is first argument from list type
-                if (actual_type := get_args(param.annotation)[0]) == Any:
-                    raise ValueError(
-                        f"Step function argument '{param.name}' cannot be serialized from database with type 'Any'"
-                    )
-                subscriptions = [actual_type.from_subscription(subscription_id) for subscription_id in subscription_ids]
-                arguments.append(subscriptions)
-            elif is_optional_type(param.annotation, SubscriptionModel):
-                subscription_id = _get_sub_id(state.get(name))
-                if subscription_id:
-                    # Actual type is first argument from optional type
-                    sub_mod = get_args(param.annotation)[0].from_subscription(subscription_id)
-                    arguments.append(sub_mod)
+                value = state[name]
+                if param.annotation == UUID:
+                    arguments.append(_convert_to_uuid(value))
+                elif is_list_type(param.annotation, UUID):
+                    arguments.append([_convert_to_uuid(item) for item in value])
+                elif is_optional_type(param.annotation, UUID):
+                    arguments.append(None if value is None else _convert_to_uuid(value))
                 else:
-                    arguments.append(None)
-            elif param.default is not inspect.Parameter.empty:
-                arguments.append(state.get(name, param.default))
-            else:
-                try:
-                    arguments.append(state[name])
-                except KeyError as key_error:
-                    logger.error("Could not find key in state.", key=name, state=state)
-                    raise KeyError(
-                        f"Could not find key '{name}' in state. for function {func.__module__}.{func.__qualname__}"
-                    ) from key_error
+                    arguments.append(value)
+            except KeyError as key_error:
+                logger.error("Could not find key in state.", key=name, state=state)
+                raise KeyError(
+                    f"Could not find key '{name}' in state. for function {func.__module__}.{func.__qualname__}"
+                ) from key_error
+            except ValueError as value_error:
+                logger.error("Could not convert value to expected type.", key=name, state=state, value=state[name])
+                raise ValueError(f"Could not convert value '{state[name]}' to {param.annotation}") from value_error
+
     return arguments
 
 

orchestrator/websocket/websocket_manager.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/workflow.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# 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
@@ -39,6 +39,7 @@ from structlog.contextvars import bound_contextvars
 from structlog.stdlib import BoundLogger
 
 from nwastdlib import const, identity
+from oauth2_lib.fastapi import OIDCUserModel
 from orchestrator.config.assignee import Assignee
 from orchestrator.db import db, transactional
 from orchestrator.services.settings import get_engine_settings
@@ -69,6 +70,7 @@ step_log_fn_var: contextvars.ContextVar[StepLogFuncInternal] = contextvars.Conte
 
 DEFAULT_CALLBACK_ROUTE_KEY = "callback_route"
 CALLBACK_TOKEN_KEY = "__callback_token"  # noqa: S105
+DEFAULT_CALLBACK_PROGRESS_KEY = "callback_progress"  # noqa: S105
 
 
 @runtime_checkable
@@ -88,6 +90,7 @@ class Workflow(Protocol):
     __qualname__: str
     name: str
     description: str
+    authorize_callback: Callable[[OIDCUserModel | None], bool]
     initial_input_form: InputFormGenerator | None = None
     target: Target
     steps: StepList
@@ -177,12 +180,18 @@ def _handle_simple_input_form_generator(f: StateInputStepFunc) -> StateInputForm
     return form_generator
 
 
+def allow(_: OIDCUserModel | None) -> bool:
+    """Default function to return True in absence of user-defined authorize function."""
+    return True
+
+
 def make_workflow(
     f: Callable,
     description: str,
     initial_input_form: InputStepFunc | None,
     target: Target,
     steps: StepList,
+    authorize_callback: Callable[[OIDCUserModel | None], bool] | None = None,
 ) -> Workflow:
     @functools.wraps(f)
     def wrapping_function() -> NoReturn:
@@ -192,6 +201,7 @@ def make_workflow(
 
     wrapping_function.name = f.__name__  # default, will be changed by LazyWorkflowInstance
     wrapping_function.description = description
+    wrapping_function.authorize_callback = allow if authorize_callback is None else authorize_callback
 
     if initial_input_form is None:
         # We always need a form to prevent starting a workflow when no input is needed.
@@ -458,7 +468,10 @@ def focussteps(key: str) -> Callable[[Step | StepList], StepList]:
 
 
 def workflow(
-    description: str, initial_input_form: InputStepFunc | None = None, target: Target = Target.SYSTEM
+    description: str,
+    initial_input_form: InputStepFunc | None = None,
+    target: Target = Target.SYSTEM,
+    authorize_callback: Callable[[OIDCUserModel | None], bool] | None = None,
 ) -> Callable[[Callable[[], StepList]], Workflow]:
     """Transform an initial_input_form and a step list into a workflow.
 
@@ -478,7 +491,9 @@ def workflow(
         initial_input_form_in_form_inject_args = form_inject_args(initial_input_form)
 
     def _workflow(f: Callable[[], StepList]) -> Workflow:
-        return make_workflow(f, description, initial_input_form_in_form_inject_args, target, f())
+        return make_workflow(
+            f, description, initial_input_form_in_form_inject_args, target, f(), authorize_callback=authorize_callback
+        )
 
     return _workflow
 
@@ -490,13 +505,14 @@ class ProcessStat:
     state: Process
     log: StepList
     current_user: str
+    user_model: OIDCUserModel | None = None
 
     def update(self, **vs: Any) -> ProcessStat:
         """Update ProcessStat.
 
         >>> pstat = ProcessStat('', None, {}, [], "")
         >>> pstat.update(state={"a": "b"})
-        ProcessStat(process_id='', workflow=None, state={'a': 'b'}, log=[], current_user='')
+        ProcessStat(process_id='', workflow=None, state={'a': 'b'}, log=[], current_user='', user_model=None)
         """
         return ProcessStat(**{**asdict(self), **vs})
 

orchestrator/workflows/modify_note.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/workflows/steps.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/workflows/tasks/cleanup_tasks_log.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/workflows/tasks/resume_workflows.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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

orchestrator/workflows/tasks/validate_product_type.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2024 SURF.
+# Copyright 2019-2024 SURF, GÉANT.
 # 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

orchestrator/workflows/tasks/validate_products.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # 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