operaton-external-task-client-python3 1.0.0__py3-none-any.whl

examples/bpmn_error_example.py

@@ -0,0 +1,75 @@
+import logging
+from concurrent.futures.thread import ThreadPoolExecutor
+
+from operaton.external_task.external_task import ExternalTask
+from operaton.external_task.external_task_worker import ExternalTaskWorker
+from operaton.utils.log_utils import log_with_context
+
+logger = logging.getLogger(__name__)
+
+default_config = {
+    "maxTasks": 1,
+    "lockDuration": 10000,
+    "asyncResponseTimeout": 30000,
+    "retries": 3,
+    "retryTimeout": 5000,
+    "sleepSeconds": 30,
+    "isDebug": True,
+}
+
+
+def validate_image(task: ExternalTask):
+    """
+    To simulate BPMN/Failure/Success, this handler uses image name variable (to be passed when launching the process)
+    """
+    log_context = {"WORKER_ID": task.get_worker_id(),
+                   "TASK_ID": task.get_task_id(),
+                   "TOPIC": task.get_topic_name()}
+
+    log_with_context("executing validate_image", log_context)
+    img_name = task.get_variable('imgName')
+
+    if "poor" in img_name:
+        return task.bpmn_error("POOR_QUALITY_IMAGE", "Image quality is bad",
+                               {"img_rejection_code": "POOR_QUALITY_CODE_XX",
+                                "img_rejection_reason": f"Image quality must be at least GOOD"})
+    elif "jpg" in img_name:
+        return task.complete({"img_approved": True})
+    elif "corrupt" in img_name:
+        return task.failure("Cannot validate image", "image is corrupted", 0, default_config.get("retryTimeout"))
+    else:
+        return task.bpmn_error("INVALID_IMAGE", "Image extension must be jpg",
+                               {"img_rejection_code": "INVALID_IMG_NAME",
+                                "img_rejection_reason": f"Image name {img_name} is invalid"})
+
+
+def generic_task_handler(task: ExternalTask):
+    log_context = {"WORKER_ID": task.get_worker_id(),
+                   "TASK_ID": task.get_task_id(),
+                   "TOPIC": task.get_topic_name()}
+
+    log_with_context("executing generic task handler", log_context)
+    return task.complete()
+
+
+def main():
+    configure_logging()
+    topics = [("VALIDATE_IMAGE", validate_image),
+              # ("APPROVE_IMAGE", generic_task_handler),
+              # ("REJECT_IMAGE", generic_task_handler),
+              # ("ENHANCE_IMAGE_QUALITY", generic_task_handler),
+              ]
+    executor = ThreadPoolExecutor(max_workers=len(topics))
+    for index, topic_handler in enumerate(topics):
+        topic = topic_handler[0]
+        handler_func = topic_handler[1]
+        executor.submit(ExternalTaskWorker(worker_id=index, config=default_config).subscribe, topic, handler_func)
+
+
+def configure_logging():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s",
+                        handlers=[logging.StreamHandler()])
+
+
+if __name__ == '__main__':
+    main()

examples/correlate_message.py

@@ -0,0 +1,11 @@
+from operaton.client.engine_client import EngineClient
+
+
+def main():
+    client = EngineClient()
+    resp_json = client.correlate_message("CANCEL_MESSAGE", business_key="b4a6f392-12ab-11eb-80ef-acde48001122")
+    print(resp_json)
+
+
+if __name__ == '__main__':
+    main()

examples/event_subprocess_example.py

@@ -0,0 +1,50 @@
+import logging
+from concurrent.futures.thread import ThreadPoolExecutor
+
+from operaton.external_task.external_task import ExternalTask
+from operaton.external_task.external_task_worker import ExternalTaskWorker
+from operaton.utils.log_utils import log_with_context
+
+logger = logging.getLogger(__name__)
+
+default_config = {
+    "maxTasks": 1,
+    "lockDuration": 10000,
+    "asyncResponseTimeout": 30000,
+    "retries": 3,
+    "retryTimeout": 5000,
+    "sleepSeconds": 30,
+    "isDebug": True,
+}
+
+
+def generic_task_handler(task: ExternalTask):
+    log_context = {"WORKER_ID": task.get_worker_id(),
+                   "TASK_ID": task.get_task_id(),
+                   "TOPIC": task.get_topic_name()}
+
+    log_with_context("executing generic task handler", log_context)
+    return task.complete()
+
+
+def main():
+    configure_logging()
+    topics = [
+        ("STEP_1", generic_task_handler),
+        # ("STEP_2", generic_task_handler),
+        # ("CLEAN_UP", generic_task_handler),
+    ]
+    executor = ThreadPoolExecutor(max_workers=len(topics))
+    for index, topic_handler in enumerate(topics):
+        topic = topic_handler[0]
+        handler_func = topic_handler[1]
+        executor.submit(ExternalTaskWorker(worker_id=index, config=default_config).subscribe, topic, handler_func)
+
+
+def configure_logging():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s",
+                        handlers=[logging.StreamHandler()])
+
+
+if __name__ == '__main__':
+    main()

examples/examples_auth_basic/fetch_and_execute.py

@@ -0,0 +1,31 @@
+import logging
+
+from operaton.external_task.external_task_worker import ExternalTaskWorker
+from task_handler_example import handle_task
+
+logger = logging.getLogger(__name__)
+
+default_config = {
+    "auth_basic": {"username": "demo", "password": "demo"},
+    "maxTasks": 1,
+    "lockDuration": 10000,
+    "asyncResponseTimeout": 0,
+    "isDebug": True,
+}
+
+
+def main():
+    configure_logging()
+    topics = ["PARALLEL_STEP_1", "PARALLEL_STEP_2", "COMBINE_STEP"]
+    for index, topic in enumerate(topics):
+        ExternalTaskWorker(worker_id=index, config=default_config) \
+            .fetch_and_execute(topic_names=topic, action=handle_task, process_variables={"strVar": "hello"})
+
+
+def configure_logging():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s",
+                        handlers=[logging.StreamHandler()])
+
+
+if __name__ == '__main__':
+    main()

examples/examples_auth_basic/get_process_instance.py

@@ -0,0 +1,12 @@
+from operaton.client.engine_client import EngineClient
+
+
+def main():
+    client = EngineClient(config={"auth_basic": {"username": "demo", "password": "demo"}})
+    resp_json = client.get_process_instance("PARALLEL_STEPS_EXAMPLE", ["intVar_eq_1", "strVar_eq_hello"],
+                                            ["6172cdf0-7b32-4460-9da0-ded5107aa977"])
+    print(resp_json)
+
+
+if __name__ == '__main__':
+    main()

examples/examples_auth_basic/start_process.py

@@ -0,0 +1,15 @@
+import uuid
+
+from operaton.client.engine_client import EngineClient
+
+
+def main():
+    client = EngineClient(config={"auth_basic": {"username": "demo", "password": "demo"}})
+    resp_json = client.start_process(
+        process_key="PARALLEL_STEPS_EXAMPLE", variables={"intVar": "1", "strVar": "hello"},
+        tenant_id="6172cdf0-7b32-4460-9da0-ded5107aa977", business_key=str(uuid.uuid1()))
+    print(resp_json)
+
+
+if __name__ == '__main__':
+    main()

examples/examples_auth_basic/task_handler_example.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from random import randint
+
+import time
+
+from operaton.external_task.external_task import ExternalTask
+from operaton.utils.log_utils import log_with_context
+
+
+def handle_task(task: ExternalTask):
+    log_context = {"WORKER_ID": task.get_worker_id(),
+                   "TASK_ID": task.get_task_id(),
+                   "TOPIC": task.get_topic_name()}
+
+    log_with_context(f"handle_task started: business key = {task.get_business_key()}", log_context)
+
+    # simulate task execution
+    execution_time = randint(0, 10)
+    log_with_context(f"handle_task - business logic execution started for task: "
+                     f"it will execute for {execution_time} seconds", log_context)
+    time.sleep(execution_time)
+
+    # simulate that task results randomly into failure/BPMN error/complete
+    failure = random_true()
+    bpmn_error = False if failure else random_true()
+    # override the values to simulate success/failure/BPMN error explicitly (if needed)
+    failure, bpmn_error = False, False
+    log_with_context(f"handle_task - business logic executed: failure: {failure}, bpmn_error: {bpmn_error}",
+                     log_context)
+
+    return __handle_task_result(task, failure, bpmn_error)
+
+
+def __handle_task_result(task, failure, bpmn_error):
+    if failure:
+        return task.failure("task failed", "failed task details", 3, 5000)
+    elif bpmn_error:
+        return task.bpmn_error("BPMN_ERROR_CODE")
+    return task.complete({"success": True, "task_completed_on": str(datetime.now())})
+
+
+def random_true():
+    current_milli_time = int(round(time.time() * 1000))
+    return current_milli_time % 2 == 0

examples/fetch_and_execute.py

@@ -0,0 +1,30 @@
+import logging
+
+from operaton.external_task.external_task_worker import ExternalTaskWorker
+from examples.task_handler_example import handle_task
+
+logger = logging.getLogger(__name__)
+
+default_config = {
+    "maxTasks": 1,
+    "lockDuration": 10000,
+    "asyncResponseTimeout": 0,
+    "isDebug": True,
+}
+
+
+def main():
+    configure_logging()
+    topics = ["PARALLEL_STEP_1", "PARALLEL_STEP_2", "COMBINE_STEP"]
+    for index, topic in enumerate(topics):
+        ExternalTaskWorker(worker_id=index, config=default_config) \
+            .fetch_and_execute(topic_names=topic, action=handle_task, process_variables={"strVar": "hello"})
+
+
+def configure_logging():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s",
+                        handlers=[logging.StreamHandler()])
+
+
+if __name__ == '__main__':
+    main()

examples/get_process_instance.py

@@ -0,0 +1,12 @@
+from operaton.client.engine_client import EngineClient
+
+
+def main():
+    client = EngineClient()
+    resp_json = client.get_process_instance("PARALLEL_STEPS_EXAMPLE", ["intVar_eq_1", "strVar_eq_hello"],
+                                            ["6172cdf0-7b32-4460-9da0-ded5107aa977"])
+    print(resp_json)
+
+
+if __name__ == '__main__':
+    main()

examples/retry_task_example.py

@@ -0,0 +1,58 @@
+import logging
+from concurrent.futures.thread import ThreadPoolExecutor
+
+from operaton.external_task.external_task import ExternalTask
+from operaton.external_task.external_task_worker import ExternalTaskWorker
+from operaton.utils.log_utils import log_with_context
+
+logger = logging.getLogger(__name__)
+
+default_config = {
+    "maxTasks": 1,
+    "lockDuration": 10000,
+    "asyncResponseTimeout": 30000,
+    "retries": 3,
+    "retryTimeout": 5000,
+    "sleepSeconds": 30,
+    "isDebug": True,
+}
+
+
+def generic_task_handler(task: ExternalTask):
+    log_context = {"WORKER_ID": task.get_worker_id(),
+                   "TASK_ID": task.get_task_id(),
+                   "TOPIC": task.get_topic_name()}
+
+    log_with_context("executing generic task handler", log_context)
+    return task.complete()
+
+
+def fail_task_handler(task: ExternalTask):
+    log_context = {"WORKER_ID": task.get_worker_id(),
+                   "TASK_ID": task.get_task_id(),
+                   "TOPIC": task.get_topic_name()}
+
+    log_with_context("executing fail_task_handler", log_context)
+    return task.failure("task failed", "task failed forced", 0, 10)
+
+
+def main():
+    configure_logging()
+    topics = [
+        ("TASK_1", fail_task_handler),
+        ("TASK_2", fail_task_handler),
+    ]
+    executor = ThreadPoolExecutor(max_workers=len(topics))
+    for index, topic_handler in enumerate(topics):
+        topic = topic_handler[0]
+        handler_func = topic_handler[1]
+        executor.submit(ExternalTaskWorker(worker_id=index, config=default_config).subscribe, topic, handler_func)
+
+
+def configure_logging():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s",
+                        handlers=[logging.StreamHandler()])
+
+
+if __name__ == '__main__':
+    main()

examples/start_process.py

@@ -0,0 +1,14 @@
+import uuid
+
+from operaton.client.engine_client import EngineClient
+
+
+def main():
+    client = EngineClient()
+    resp_json = client.start_process(process_key="PARALLEL_STEPS_EXAMPLE", variables={"intVar": "1", "strVar": "hello"},
+                                     tenant_id="6172cdf0-7b32-4460-9da0-ded5107aa977", business_key=str(uuid.uuid1()))
+    print(resp_json)
+
+
+if __name__ == '__main__':
+    main()

examples/task_handler_example.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from random import randint
+
+import time
+
+from operaton.external_task.external_task import ExternalTask
+from operaton.utils.log_utils import log_with_context
+
+
+def handle_task(task: ExternalTask):
+    log_context = {"WORKER_ID": task.get_worker_id(),
+                   "TASK_ID": task.get_task_id(),
+                   "TOPIC": task.get_topic_name()}
+
+    log_with_context(f"handle_task started: business key = {task.get_business_key()}", log_context)
+
+    # simulate task execution
+    execution_time = randint(0, 10)
+    log_with_context(f"handle_task - business logic execution started for task: "
+                     f"it will execute for {execution_time} seconds", log_context)
+    time.sleep(execution_time)
+
+    # simulate that task results randomly into failure/BPMN error/complete
+    failure = random_true()
+    bpmn_error = False if failure else random_true()
+    # override the values to simulate success/failure/BPMN error explicitly (if needed)
+    failure, bpmn_error = False, False
+    log_with_context(f"handle_task - business logic executed: failure: {failure}, bpmn_error: {bpmn_error}",
+                     log_context)
+
+    return __handle_task_result(task, failure, bpmn_error)
+
+
+def __handle_task_result(task, failure, bpmn_error):
+    if failure:
+        return task.failure("task failed", "failed task details", 3, 5000)
+    elif bpmn_error:
+        return task.bpmn_error("BPMN_ERROR_CODE")
+    return task.complete({"success": True, "task_completed_on": str(datetime.now())})
+
+
+def random_true():
+    current_milli_time = int(round(time.time() * 1000))
+    return current_milli_time % 2 == 0

examples/tasks_example.py

@@ -0,0 +1,36 @@
+import logging
+from concurrent.futures.thread import ThreadPoolExecutor
+
+from operaton.external_task.external_task_worker import ExternalTaskWorker
+from examples.task_handler_example import handle_task
+
+logger = logging.getLogger(__name__)
+
+default_config = {
+    "maxTasks": 1,
+    "lockDuration": 10000,
+    "asyncResponseTimeout": 3000,
+    "retries": 3,
+    "retryTimeout": 5000,
+    "sleepSeconds": 30,
+    "isDebug": True,
+    "httpTimeoutMillis": 3000,
+}
+
+
+def main():
+    configure_logging()
+    topics = ["PARALLEL_STEP_1", "PARALLEL_STEP_2", "COMBINE_STEP"]
+    executor = ThreadPoolExecutor(max_workers=len(topics))
+    for index, topic in enumerate(topics):
+        executor.submit(ExternalTaskWorker(worker_id=index, config=default_config).subscribe, topic, handle_task,
+                        {"strVar": "hello"})
+
+
+def configure_logging():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s",
+                        handlers=[logging.StreamHandler()])
+
+
+if __name__ == '__main__':
+    main()

operaton/client/async_external_task_client.py

@@ -0,0 +1,171 @@
+import logging
+from http import HTTPStatus
+
+import httpx
+
+from operaton.client.engine_client import ENGINE_LOCAL_BASE_URL
+from operaton.utils.log_utils import log_with_context
+from operaton.utils.response_utils import raise_exception_if_not_ok
+from operaton.utils.utils import str_to_list
+from operaton.utils.auth_basic import AuthBasic, obfuscate_password
+from operaton.utils.auth_bearer import AuthBearer
+from operaton.variables.variables import Variables
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncExternalTaskClient:
+    default_config = {
+        "maxConcurrentTasks": 10,  # Number of concurrent tasks you can process
+        "lockDuration": 300000,  # in milliseconds
+        "asyncResponseTimeout": 30000,
+        "retries": 3,
+        "retryTimeout": 300000,
+        "httpTimeoutMillis": 30000,
+        "timeoutDeltaMillis": 5000,
+        "includeExtensionProperties": True,  # enables Camunda Extension Properties
+        "deserializeValues": True,  # deserialize values when fetch a task by default
+        "usePriority": False,
+        "sorting": None
+    }
+
+    def __init__(self, worker_id, engine_base_url=ENGINE_LOCAL_BASE_URL, config=None):
+        config = config if config is not None else {}
+        self.worker_id = worker_id
+        self.external_task_base_url = engine_base_url + "/external-task"
+        self.config = type(self).default_config.copy()
+        self.config.update(config)
+        self.is_debug = config.get('isDebug', False)
+        self.http_timeout_seconds = self.config.get('httpTimeoutMillis') / 1000
+        self._log_with_context(f"Created External Task client with config: {obfuscate_password(self.config)}")
+
+    def get_fetch_and_lock_url(self):
+        return f"{self.external_task_base_url}/fetchAndLock"
+
+    async def fetch_and_lock(self, topic_names, process_variables=None, variables=None):
+        url = self.get_fetch_and_lock_url()
+        body = {
+            "workerId": str(self.worker_id),  # convert to string to make it JSON serializable
+            "maxTasks": 1,
+            "topics": self._get_topics(topic_names, process_variables, variables),
+            "asyncResponseTimeout": self.config["asyncResponseTimeout"],
+            "usePriority": self.config["usePriority"],
+            "sorting": self.config["sorting"]
+        }
+
+        if self.is_debug:
+            self._log_with_context(f"Trying to fetch and lock with request payload: {body}")
+        http_timeout_seconds = self.__get_fetch_and_lock_http_timeout_seconds()
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=self._get_headers(), json=body, timeout=http_timeout_seconds)
+        raise_exception_if_not_ok(response)
+
+        resp_json = response.json()
+        if self.is_debug:
+            self._log_with_context(f"Fetch and lock response JSON: {resp_json} for request: {body}")
+        return resp_json
+
+    def __get_fetch_and_lock_http_timeout_seconds(self):
+        # Use HTTP timeout slightly more than async response / long polling timeout
+        return (self.config["timeoutDeltaMillis"] + self.config["asyncResponseTimeout"]) / 1000
+
+    def _get_topics(self, topic_names, process_variables, variables):
+        topics = []
+        for topic in str_to_list(topic_names):
+            topics.append({
+                "topicName": topic,
+                "lockDuration": self.config["lockDuration"],
+                "processVariables": process_variables if process_variables else {},
+                # Enables Camunda Extension Properties
+                "includeExtensionProperties": self.config.get("includeExtensionProperties") or False,
+                "deserializeValues": self.config["deserializeValues"],
+                "variables": variables
+            })
+        return topics
+
+    async def complete(self, task_id, global_variables, local_variables=None):
+        url = self.get_task_complete_url(task_id)
+
+        body = {
+            "workerId": self.worker_id,
+            "variables": Variables.format(global_variables),
+            "localVariables": Variables.format(local_variables)
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=self._get_headers(), json=body, timeout=self.http_timeout_seconds)
+        raise_exception_if_not_ok(response)
+        return response.status_code == HTTPStatus.NO_CONTENT
+
+    def get_task_complete_url(self, task_id):
+        return f"{self.external_task_base_url}/{task_id}/complete"
+
+    async def failure(self, task_id, error_message, error_details, retries, retry_timeout):
+        url = self.get_task_failure_url(task_id)
+        logger.info(f"Setting retries to: {retries} for task: {task_id}")
+        body = {
+            "workerId": self.worker_id,
+            "errorMessage": error_message,
+            "retries": retries,
+            "retryTimeout": retry_timeout,
+        }
+        if error_details:
+            body["errorDetails"] = error_details
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=self._get_headers(), json=body, timeout=self.http_timeout_seconds)
+        raise_exception_if_not_ok(response)
+        return response.status_code == HTTPStatus.NO_CONTENT
+
+    def get_task_failure_url(self, task_id):
+        return f"{self.external_task_base_url}/{task_id}/failure"
+
+    async def bpmn_failure(self, task_id, error_code, error_message, variables=None):
+        url = self.get_task_bpmn_error_url(task_id)
+
+        body = {
+            "workerId": self.worker_id,
+            "errorCode": error_code,
+            "errorMessage": error_message,
+            "variables": Variables.format(variables),
+        }
+
+        if self.is_debug:
+            self._log_with_context(f"Trying to report BPMN error with request payload: {body}")
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=self._get_headers(), json=body, timeout=self.http_timeout_seconds)
+        response.raise_for_status()
+        return response.status_code == HTTPStatus.NO_CONTENT
+
+    def get_task_bpmn_error_url(self, task_id):
+        return f"{self.external_task_base_url}/{task_id}/bpmnError"
+
+    @property
+    def auth_basic(self) -> dict:
+        if not self.config.get("auth_basic") or not isinstance(self.config.get("auth_basic"), dict):
+            return {}
+        token = AuthBasic(**self.config.get("auth_basic").copy()).token
+        return {"Authorization": token}
+
+    @property
+    def auth_bearer(self) -> dict:
+        if not self.config.get("auth_bearer") or not isinstance(self.config.get("auth_bearer"), dict):
+            return {}
+        token = AuthBearer(access_token=self.config["auth_bearer"]).access_token
+        return {"Authorization": token}
+
+    def _get_headers(self):
+        headers = {
+            "Content-Type": "application/json"
+        }
+        if self.auth_basic:
+            headers.update(self.auth_basic)
+        if self.auth_bearer:
+            headers.update(self.auth_bearer)
+        return headers
+
+    def _log_with_context(self, msg, log_level='info', **kwargs):
+        context = {"WORKER_ID": self.worker_id}
+        log_with_context(msg, context=context, log_level=log_level, **kwargs)