Make use of new callback step for external provisioning

Interaction with LSO is now completely reworked. More efficient, more faster, more better, more prettier, and will make us all rich

Depends on lso!51 (merged)

gso/services/provisioning_proxy.py

@@ -4,25 +4,24 @@
 """
 import json
 import logging
+from functools import partial
 
 import requests
-from orchestrator import conditional, inputstep, step
+from orchestrator import step
 from orchestrator.config.assignee import Assignee
-from orchestrator.domain import SubscriptionModel
-from orchestrator.forms import FormPage, ReadOnlyField
-from orchestrator.forms.validators import Accept, Label, LongText
-from orchestrator.types import FormGenerator, State, UUIDstr, strEnum
+from orchestrator.types import State, UUIDstr, strEnum
+from orchestrator.utils.errors import ProcessFailureError
 from orchestrator.utils.json import json_dumps
-from orchestrator.workflow import Step, StepList, abort, init
-from pydantic import validator
+from orchestrator.workflow import Step, StepList, begin, callback_step, inputstep
+from pydantic_forms.core import FormPage, ReadOnlyField
+from pydantic_forms.types import FormGenerator
+from pydantic_forms.validators import LongText
 
 from gso import settings
 from gso.products.product_types.iptrunk import Iptrunk, IptrunkProvisioning
 from gso.products.product_types.router import Router, RouterProvisioning
 
 logger = logging.getLogger(__name__)
-DEFAULT_LABEL = "Provisioning proxy is running. Please come back later for the results."
-"""The default label displayed when the provisioning proxy is running, in case no custom label is provided."""
 
 
 class CUDOperation(strEnum):
@@ -36,20 +35,19 @@ class CUDOperation(strEnum):
     DELETE = "DELETE"
 
 
-def _send_request(endpoint: str, parameters: dict, process_id: UUIDstr, operation: CUDOperation) -> None:
+def _send_request(operation: CUDOperation, endpoint: str, parameters: dict, callback_route: str) -> None:
     """Send a request to :term:`LSO`. The callback address is derived using the process ID provided.
 
+    :param operation: The specific operation that's performed with the request.
+    :type operation: :class:`CUDOperation`
     :param endpoint: The :term:`LSO`-specific endpoint to call, depending on the type of service object that's acted
         upon.
     :type endpoint: str
     :param parameters: JSON body for the request, which will almost always at least consist of a subscription object,
         and a boolean value to indicate a dry run.
     :type parameters: dict
-    :param process_id: The process ID that this request is a part of, used to call back to when the execution of the
-        playbook is completed.
-    :type process_id: UUIDstr
-    :param operation: The specific operation that's performed with the request.
-    :type operation: :class:`CUDOperation`
+    :param callback_route: The callback route that should be used to resume the workflow.
+    :type callback_route: str
     :rtype: None
     """
     oss = settings.load_oss_params()
@@ -57,8 +55,7 @@ def _send_request(endpoint: str, parameters: dict, process_id: UUIDstr, operatio
     assert pp_params
 
     # Build up a callback URL of the Provisioning Proxy to return its results to.
-    callback_url = f"{settings.load_oss_params().GENERAL.public_hostname}" f"/api/processes/{process_id}/resume"
-    logger.debug(f"[provisioning proxy] provisioning for process {process_id}")
+    callback_url = f"{oss.GENERAL.public_hostname}{callback_route}"
     logger.debug(f"[provisioning proxy] Callback URL set to {callback_url}")
 
     parameters.update({"callback": callback_url})
@@ -79,8 +76,13 @@ def _send_request(endpoint: str, parameters: dict, process_id: UUIDstr, operatio
         raise AssertionError(request.content)
 
 
+_send_post = partial(_send_request, CUDOperation.POST)
+_send_put = partial(_send_request, CUDOperation.PUT)
+_send_delete = partial(_send_request, CUDOperation.DELETE)
+
+
 def provision_router(
-    subscription: RouterProvisioning, process_id: UUIDstr, tt_number: str, dry_run: bool = True
+    subscription: RouterProvisioning, process_id: UUIDstr, callback_route: str, tt_number: str, dry_run: bool = True
 ) -> None:
     """Provision a new router using :term:`LSO`.
 
@@ -88,6 +90,10 @@ def provision_router(
     :type subscription: :class:`RouterProvisioning`
     :param process_id: The related process ID, used for callback.
     :type process_id: UUIDstr
+    :param callback_route: The API endpoint that should be used for the callback URL.
+    :type callback_route: str
+    :param tt_number: Trouble ticket number related to the operation.
+    :type tt_number: str
     :param dry_run: A boolean indicating whether this should be a dry run or not, defaults to `True`.
     :type dry_run: bool
     :rtype: None
@@ -99,12 +105,13 @@ def provision_router(
         "subscription": json.loads(json_dumps(subscription)),
     }
 
-    _send_request("router", parameters, process_id, CUDOperation.POST)
+    _send_post("router", parameters, callback_route)
 
 
 def provision_ip_trunk(
     subscription: IptrunkProvisioning,
     process_id: UUIDstr,
+    callback_route: str,
     tt_number: str,
     config_object: str,
     dry_run: bool = True,
@@ -116,6 +123,10 @@ def provision_ip_trunk(
     :type subscription: :class:`IptrunkProvisioning`
     :param process_id: The related process ID, used for callback.
     :type process_id: UUIDstr
+    :param callback_route: The API endpoint that should be used for the callback URL.
+    :type callback_route: str
+    :param tt_number: Trouble ticket number related to the operation.
+    :type tt_number: str
     :param config_object: The type of object that's deployed.
     :type config_object: str
     :param dry_run: A boolean indicating whether this should be a dry run or not, defaults to `True`.
@@ -134,16 +145,22 @@ def provision_ip_trunk(
         "removed_ae_members": removed_ae_members,
     }
 
-    _send_request("ip_trunk", parameters, process_id, CUDOperation.POST)
+    _send_post("ip_trunk", parameters, callback_route)
 
 
-def check_ip_trunk(subscription: IptrunkProvisioning, process_id: UUIDstr, tt_number: str, check_name: str) -> None:
+def check_ip_trunk(
+    subscription: IptrunkProvisioning, process_id: UUIDstr, callback_route: str, tt_number: str, check_name: str
+) -> None:
     """Provision an IP trunk service using :term:`LSO`.
 
     :param subscription: The subscription object that's to be provisioned.
     :type subscription: :class:`IptrunkProvisioning`
     :param process_id: The related process ID, used for callback.
     :type process_id: UUIDstr
+    :param callback_route: The API endpoint that should be used for the callback URL.
+    :type callback_route: str
+    :param tt_number: Trouble ticket number related to the operation.
+    :type tt_number: str
     :param check_name: The name of the check to execute
     :rtype: None
     """
@@ -154,16 +171,22 @@ def check_ip_trunk(subscription: IptrunkProvisioning, process_id: UUIDstr, tt_nu
         "check_name": check_name,
     }
 
-    _send_request("ip_trunk/perform_check", parameters, process_id, CUDOperation.POST)
+    _send_post("ip_trunk/perform_check", parameters, callback_route)
 
 
-def deprovision_ip_trunk(subscription: Iptrunk, process_id: UUIDstr, tt_number: str, dry_run: bool = True) -> None:
+def deprovision_ip_trunk(
+    subscription: Iptrunk, process_id: UUIDstr, callback_route: str, tt_number: str, dry_run: bool = True
+) -> None:
     """Deprovision an IP trunk service using :term:`LSO`.
 
     :param subscription: The subscription object that's to be provisioned.
     :type subscription: :class:`IptrunkProvisioning`
     :param process_id: The related process ID, used for callback.
     :type process_id: UUIDstr
+    :param callback_route: The API endpoint that should be used for the callback URL.
+    :type callback_route: str
+    :param tt_number: Trouble ticket number related to the operation.
+    :type tt_number: str
     :param dry_run: A boolean indicating whether this should be a dry run or not, defaults to `True`.
     :type dry_run: bool
     :rtype: None
@@ -176,7 +199,7 @@ def deprovision_ip_trunk(subscription: Iptrunk, process_id: UUIDstr, tt_number:
         "verb": "terminate",
     }
 
-    _send_request("ip_trunk", parameters, process_id, CUDOperation.DELETE)
+    _send_delete("ip_trunk", parameters, callback_route)
 
 
 def migrate_ip_trunk(
@@ -186,6 +209,7 @@ def migrate_ip_trunk(
     new_lag_member_interfaces: list[dict],
     replace_index: int,
     process_id: UUIDstr,
+    callback_route: str,
     tt_number: str,
     verb: str,
     config_object: str,
@@ -206,8 +230,14 @@ def migrate_ip_trunk(
     :type replace_index: int
     :param process_id: The related process ID, used for callback.
     :type process_id: UUIDstr
+    :param callback_route: The :term:`API` endpoint that should be used for the callback URL.
+    :type callback_route: str
+    :param tt_number: Trouble ticket number related to the operation.
+    :type tt_number: str
     :param verb: The verb that is passed to the executed playbook
     :type verb: str
+    :param config_object: The object that is configured.
+    :type config_object: str
     :param dry_run: A boolean indicating whether this should be a dry run or not, defaults to `True`.
     :type dry_run: bool
     :rtype: None
@@ -227,144 +257,47 @@ def migrate_ip_trunk(
         "dry_run": dry_run,
     }
 
-    _send_request("ip_trunk/migrate", parameters, process_id, CUDOperation.POST)
-
-
-@inputstep("Await provisioning proxy results", assignee=Assignee.SYSTEM)
-def _await_pp_results(subscription: SubscriptionModel, label_text: str = DEFAULT_LABEL) -> FormGenerator:
-    """Input step that forces the workflow to go into a `SUSPENDED` state.
-
-    When the workflow is `SUSPENDED`, it will wait for user input to be presented before it continues running the next
-    steps of the workflow. User input is mimicked by the provisioning proxy, as it makes a `PUT` request to the callback
-    URL that it was given in `_send_request()`. This input is fabricated in such a way that it will advance the workflow
-    to the next step. This next step should always be `confirm_pp_results()`, where the operator is presented with the
-    output of the provisioning proxy.
-
-    :param subscription: The current subscription that the provisioning proxy is acting on.
-    :type subscription: :class:`orchestrator.domain.SubscriptionModel`
-    :param label_text: A label that's displayed to the operator when the provisioning proxy has not returned its
-        results yet. Defaults to `DEFAULT_LABEL`.
-    :type label_text: str
-    :return: The input that's given by the provisioning proxy, that should contain run results, and a `confirm`
-        boolean set to `True`.
-    :rtype: :class:`orchestrator.types.FormGenerator`
-    """
-
-    class ProvisioningResultPage(FormPage):
-        class Config:
-            title = f"Deploying {subscription.product.name}..."
-
-        warning_label: Label = label_text  # type: ignore[assignment]
-        pp_run_results: dict = None  # type: ignore[assignment]
-        confirm: Accept = Accept("INCOMPLETE")
-
-        @validator("pp_run_results", allow_reuse=True, pre=True, always=True)
-        def run_results_must_be_given(cls, run_results: dict) -> dict:
-            if run_results is None:
-                raise ValueError("Run results may not be empty. Wait for the provisioning proxy to finish.")
-            return run_results
+    _send_post("ip_trunk/migrate", parameters, callback_route)
 
-    result_page = yield ProvisioningResultPage
 
-    return result_page.dict()
+@step("Evaluate provisioning proxy result")
+def _evaluate_pp_results(callback_result: dict) -> State:
+    if callback_result["return_code"] != 0:
+        raise ProcessFailureError(message="Provisioning proxy failure", details=callback_result)
 
-
-@step("Reset Provisioning Proxy state")
-def _reset_pp_success_state() -> State:
-    """Reset the boolean that indicates a successful provisioning proxy result in the state of a running workflow.
-
-    :return: A new state of the workflow, where the key `pp_did_succeed` has been (re)set to false.
-    :rtype: :class:`orchestrator.types.State`
-    """
-    return {"pp_did_succeed": False}
+    return {"callback_result": callback_result}
 
 
 @inputstep("Confirm provisioning proxy results", assignee=Assignee("SYSTEM"))
-def _confirm_pp_results(state: State) -> FormGenerator:
-    """Input step where a human has to confirm the result from calling provisioning proxy.
-
-    The results of a call to the provisioning proxy are displayed, together with the fact whether this execution was
-    a success or not. If unsuccessful, an extra label is displayed that warns the user about the fact that this
-    execution will be retried. This will happen up to two times, after which the workflow will fail.
-
-    :param state: The current state of the workflow.
-    :type state: :class:`orchestrator.types.State`
-    :return: Confirmation from the user, when presented with the run results.
-    :rtype: :class:`orchestrator.types.FormGenerator`
-    """
-    if "pp_run_results" not in state:
-        # FIXME: dirty hack that makes the skipping """work"""
-        return {"pp_did_succeed": True}
-
-    class ContinueForm(FormPage):
-        class Config:
-            title = "Continue to see the result?"
-
-    yield ContinueForm
-
-    successful_run = state["pp_run_results"]["return_code"] == 0
+def _show_pp_results(state: State) -> FormGenerator:
+    if "callback_result" not in state:
+        return state
 
     class ConfirmRunPage(FormPage):
         class Config:
-            title = (
-                f"Execution for {state['subscription']['product']['name']} completed, please confirm the results below."
-            )
-
-        if not successful_run:
-            pp_retry_label1: Label = (
-                "Provisioning Proxy - playbook execution failed: "
-                "inspect the output before proceeding"  # type: ignore[assignment]
-            )
-
-        run_status: str = ReadOnlyField(state["pp_run_results"]["status"])
-        run_results: LongText = ReadOnlyField(json.dumps(state["pp_run_results"]["output"], indent=4))
-        if not successful_run:
-            pp_retry_label: Label = (
-                "Click submit to retry. Otherwise, abort the workflow from the process tab."  # type: ignore[assignment]
-            )
-
-    yield ConfirmRunPage
+            title: str = f"Execution for {state['subscription']['product']['name']} completed."
 
-    return {"pp_did_succeed": successful_run}
+        run_status: str = ReadOnlyField(state["callback_result"]["status"])
+        run_results: LongText = ReadOnlyField(json.dumps(state["callback_result"], indent=4))
 
+    yield ConfirmRunPage
+    return state
 
-def pp_interaction(provisioning_step: Step, attempts: int, abort_on_failure: bool = True) -> StepList:
-    """Interaction with the provisioning proxy.
-
-    This method returns the three steps that make up an interaction with the provisioning proxy:
-        - The provisioning step itself, given by the user as input.
-        - The input step that suspends the workflow, and will wait for results from the provisioning proxy.
-        - An input step that presents the user with the results, where they must be confirmed.
 
-    All these steps are wrapped in a :class:`orchestrator.workflow.conditional`. This ensures that when provisioning was
-    already successful, these steps are skipped. This mechanism is quite a dirty hack, and it's planned to be addressed
-    in a later release.
+def pp_interaction(provisioning_step: Step) -> StepList:
+    """Interact with the provisioning proxy :term:`LSO` using a callback step.
 
-    The parameter `attempts` indicates how many times a provisioning may be attempted. When this amount is exceeded, and
-    it's still not successful, the workflow will be aborted if so indicated with the `abort_on_failure` boolean.
+    An asynchronous interaction with the provisioning proxy. This is an external system that executes Ansible playbooks
+    in order to provision service subscriptions. If the playbook fails, this step will also fail, allowing for the user
+    to retry provisioning from the UI.
 
-    :param provisioning_step: The step that executes an interaction with the provisioning proxy.
-    :type provisioning_step: :class:`orchestrator.workflow.Step`
-    :param attempts: The maximum amount of times that a provisioning can be retried.
-    :type attempts: int
-    :param abort_on_failure: A boolean value that indicates whether a workflow should abort if the provisioning has
-                             failed the maximum amount of tries. Defaults to `True`.
-    :return: A list of three steps that form one interaction with the provisioning proxy.
-    :rtype: :class:`orchestrator.workflow.StepList`
+    :param provisioning_step: A workflow step that performs an operation remotely using the provisioning proxy.
+    :type provisioning_step: :class:`Step`
+    :return: A list of steps that is executed as part of the workflow.
+    :rtype: :class:`StepList`
     """
-    should_retry_pp_steps = conditional(lambda state: not state.get("pp_did_succeed"))
-
-    pp_steps = init >> _reset_pp_success_state
-
-    for _ in range(attempts):
-        pp_steps >>= (
-            should_retry_pp_steps(provisioning_step)
-            >> should_retry_pp_steps(_await_pp_results)
-            >> should_retry_pp_steps(_confirm_pp_results)
-        )
-
-    if abort_on_failure:
-        # Abort a workflow if provisioning has failed too many times
-        pp_steps >>= should_retry_pp_steps(abort)
-
-    return pp_steps
+    return (
+        begin
+        >> callback_step(name=provisioning_step.name, action_step=provisioning_step, validate_step=_evaluate_pp_results)
+        >> _show_pp_results
+    )