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

operaton/client/tests/test_engine_client_bearer.py

@@ -0,0 +1,237 @@
+import base64
+from http import HTTPStatus
+from unittest import TestCase
+from unittest.mock import patch
+
+import responses
+
+from operaton.client.engine_client import EngineClient, ENGINE_LOCAL_BASE_URL
+
+
+class EngineClientAuthTest(TestCase):
+    tenant_id = "6172cdf0-7b32-4460-9da0-ded5107aa977"
+    process_key = "PARALLEL_STEPS_EXAMPLE"
+
+    def setUp(self):
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        self.client = EngineClient(
+            config={"auth_bearer": {"access_token": token}})
+
+    @responses.activate
+    def test_auth_basic_start_process_success(self):
+        resp_payload = {
+            "links": [
+                {
+                    "method": "GET",
+                    "href": "http://localhost:8080/engine-rest/process-instance/cb678be8-9b93-11ea-bad9-0242ac110002",
+                    "rel": "self"
+                }
+            ],
+            "id": "cb678be8-9b93-11ea-bad9-0242ac110002",
+            "definitionId": "PARALLEL_STEPS_EXAMPLE:1:9b72da83-9b91-11ea-bad9-0242ac110002",
+            "businessKey": "123456",
+            "caseInstanceId": None,
+            "ended": False,
+            "suspended": False,
+            "tenantId": None
+        }
+        responses.add(responses.POST, self.client.get_start_process_instance_url(self.process_key, self.tenant_id),
+                      json=resp_payload, status=HTTPStatus.OK)
+        actual_resp_payload = self.client.start_process(self.process_key, {}, self.tenant_id, "123456")
+        self.assertDictEqual(resp_payload, actual_resp_payload)
+
+    @responses.activate
+    def test_auth_basic_start_process_not_found_raises_exception(self):
+        resp_payload = {
+            "type": "RestException",
+            "message": "No matching process definition with key: PROCESS_KEY_NOT_EXISTS and tenant-id: tenant_123"
+        }
+        responses.add(responses.POST,
+                      self.client.get_start_process_instance_url("PROCESS_KEY_NOT_EXISTS", self.tenant_id),
+                      status=HTTPStatus.NOT_FOUND, json=resp_payload)
+        with self.assertRaises(Exception) as exception_ctx:
+            self.client.start_process("PROCESS_KEY_NOT_EXISTS", {}, self.tenant_id)
+
+        self.assertEqual("received 404 : RestException : "
+                         "No matching process definition with key: PROCESS_KEY_NOT_EXISTS and tenant-id: tenant_123",
+                         str(exception_ctx.exception))
+
+    @responses.activate
+    def test_auth_basic_start_process_bad_request_raises_exception(self):
+        client = EngineClient()
+        expected_message = "Cannot instantiate process definition " \
+                           "PARALLEL_STEPS_EXAMPLE:1:9b72da83-9b91-11ea-bad9-0242ac110002: " \
+                           "Cannot convert value '1aa2345' of type 'Integer' to java type java.lang.Integer"
+        resp_payload = {
+            "type": "InvalidRequestException",
+            "message": expected_message
+        }
+        responses.add(responses.POST, client.get_start_process_instance_url(self.process_key, self.tenant_id),
+                      status=HTTPStatus.BAD_REQUEST, json=resp_payload)
+        with self.assertRaises(Exception) as exception_ctx:
+            client.start_process(self.process_key, {"int_var": "1aa2345"}, self.tenant_id)
+
+        self.assertEqual(f"received 400 : InvalidRequestException : {expected_message}", str(exception_ctx.exception))
+
+    @responses.activate
+    def test_auth_basic_start_process_server_error_raises_exception(self):
+        responses.add(responses.POST, self.client.get_start_process_instance_url(self.process_key, self.tenant_id),
+                      status=HTTPStatus.INTERNAL_SERVER_ERROR)
+        with self.assertRaises(Exception) as exception_ctx:
+            self.client.start_process(self.process_key, {"int_var": "1aa2345"}, self.tenant_id)
+
+        self.assertEqual(HTTPStatus.INTERNAL_SERVER_ERROR, exception_ctx.exception.response.status_code)
+        self.assertIn("Server Error: Internal Server Error", str(exception_ctx.exception))
+
+    @responses.activate
+    def test_auth_basic_get_process_instance_success(self):
+        resp_payload = [
+            {
+                "links": [],
+                "id": "c2c68785-9f42-11ea-a841-0242ac1c0004",
+                "definitionId": "PARALLEL_STEPS_EXAMPLE:1:88613042-9f42-11ea-a841-0242ac1c0004",
+                "businessKey": None,
+                "caseInstanceId": None,
+                "ended": False,
+                "suspended": False,
+                "tenantId": self.tenant_id
+            }
+        ]
+        get_process_instance_url = f"{ENGINE_LOCAL_BASE_URL}/process-instance" \
+                                   f"?processDefinitionKey={self.process_key}" \
+                                   f"&tenantIdIn={self.tenant_id}" \
+                                   f"&variables=intVar_eq_1,strVar_eq_hello"
+        responses.add(responses.GET, get_process_instance_url, status=HTTPStatus.OK, json=resp_payload)
+        actual_resp_payload = self.client.get_process_instance(process_key=self.process_key,
+                                                               variables=["intVar_eq_1", "strVar_eq_hello"],
+                                                               tenant_ids=[self.tenant_id])
+        self.assertListEqual(resp_payload, actual_resp_payload)
+
+    @responses.activate
+    def test_auth_basic_get_process_instance_bad_request_raises_exception(self):
+        expected_message = "Invalid variable comparator specified: XXX"
+        resp_payload = {
+            "type": "InvalidRequestException",
+            "message": expected_message
+        }
+        get_process_instance_url = f"{ENGINE_LOCAL_BASE_URL}/process-instance" \
+                                   f"?processDefinitionKey={self.process_key}" \
+                                   f"&tenantIdIn={self.tenant_id}" \
+                                   f"&variables=intVar_XXX_1,strVar_eq_hello"
+        responses.add(responses.GET, get_process_instance_url, status=HTTPStatus.BAD_REQUEST, json=resp_payload)
+        with self.assertRaises(Exception) as exception_ctx:
+            self.client.get_process_instance(process_key=self.process_key,
+                                             variables=["intVar_XXX_1", "strVar_eq_hello"],
+                                             tenant_ids=[self.tenant_id])
+
+        self.assertEqual(f"received 400 : InvalidRequestException : {expected_message}", str(exception_ctx.exception))
+
+    @responses.activate
+    def test_auth_basic_get_process_instance_server_error_raises_exception(self):
+        get_process_instance_url = f"{ENGINE_LOCAL_BASE_URL}/process-instance" \
+                                   f"?processDefinitionKey={self.process_key}" \
+                                   f"&tenantIdIn={self.tenant_id}" \
+                                   f"&variables=intVar_XXX_1,strVar_eq_hello"
+        responses.add(responses.GET, get_process_instance_url, status=HTTPStatus.INTERNAL_SERVER_ERROR)
+        with self.assertRaises(Exception) as exception_ctx:
+            self.client.get_process_instance(process_key=self.process_key,
+                                             variables=["intVar_XXX_1", "strVar_eq_hello"],
+                                             tenant_ids=[self.tenant_id])
+
+        self.assertEqual(HTTPStatus.INTERNAL_SERVER_ERROR, exception_ctx.exception.response.status_code)
+        self.assertIn("Server Error: Internal Server Error", str(exception_ctx.exception))
+
+    @patch('requests.post')
+    def test_auth_basic_correlate_message_with_only_message_name(self, mock_post):
+        expected_request_payload = {
+            "messageName": "CANCEL_MESSAGE",
+            "withoutTenantId": True,
+            "resultEnabled": True
+        }
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        self.client.correlate_message("CANCEL_MESSAGE")
+        mock_post.assert_called_with(ENGINE_LOCAL_BASE_URL + "/message",
+                                     json=expected_request_payload,
+                                     headers={'Content-Type': 'application/json',
+                                              'Authorization': f'Bearer {token}'})
+
+    @patch('requests.post')
+    def test_auth_basic_correlate_message_with_business_key(self, mock_post):
+        expected_request_payload = {
+            "messageName": "CANCEL_MESSAGE",
+            "withoutTenantId": True,
+            "businessKey": "123456",
+            "resultEnabled": True
+        }
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        self.client.correlate_message("CANCEL_MESSAGE", business_key="123456")
+        mock_post.assert_called_with(ENGINE_LOCAL_BASE_URL + "/message",
+                                     json=expected_request_payload,
+                                     headers={'Content-Type': 'application/json',
+                                              'Authorization': f'Bearer {token}'})
+
+    @patch('requests.post')
+    def test_auth_basic_correlate_message_with_tenant_id(self, mock_post):
+        expected_request_payload = {
+            "messageName": "CANCEL_MESSAGE",
+            "withoutTenantId": False,
+            "tenantId": "123456",
+            "resultEnabled": True
+        }
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        self.client.correlate_message("CANCEL_MESSAGE", tenant_id="123456")
+        mock_post.assert_called_with(ENGINE_LOCAL_BASE_URL + "/message",
+                                     json=expected_request_payload,
+                                     headers={'Content-Type': 'application/json',
+                                              'Authorization': f'Bearer {token}'})
+
+    @responses.activate
+    def test_auth_basic_correlate_message_invalid_message_name_raises_exception(self):
+        expected_message = "org.operaton.bpm.engine.MismatchingMessageCorrelationException: " \
+                           "Cannot correlate message 'XXX': No process definition or execution matches the parameters"
+        resp_payload = {
+            "type": "RestException",
+            "message": expected_message
+        }
+        correlate_msg_url = f"{ENGINE_LOCAL_BASE_URL}/message"
+        responses.add(responses.POST, correlate_msg_url, status=HTTPStatus.BAD_REQUEST, json=resp_payload)
+        with self.assertRaises(Exception) as exception_ctx:
+            self.client.correlate_message(message_name="XXX")
+
+        self.assertEqual(f"received 400 : RestException : {expected_message}", str(exception_ctx.exception))
+
+    @responses.activate
+    def test_auth_basic_get_process_instance_variable_without_meta(self):
+        process_instance_id = "c2c68785-9f42-11ea-a841-0242ac1c0004"
+        variable_name = "var1"
+        process_instance_var_url = \
+            f"{ENGINE_LOCAL_BASE_URL}/process-instance/{process_instance_id}/variables/{variable_name}"
+        resp_frame_payload = {"value": None, "valueInfo": {}, "type": ""}
+        resp_data_payload = base64.decodebytes(b"operaton")
+        process_instance_var_data_url = f"{process_instance_var_url}/data"
+
+        responses.add(responses.GET, process_instance_var_url, status=HTTPStatus.OK, json=resp_frame_payload)
+        responses.add(responses.GET, process_instance_var_data_url, status=HTTPStatus.OK, body=resp_data_payload)
+
+        resp = self.client.get_process_instance_variable(process_instance_id, variable_name)
+        self.assertEqual("operaton\n", resp)
+
+    @responses.activate
+    def test_auth_basic_get_process_instance_variable_with_meta(self):
+        process_instance_id = "c2c68785-9f42-11ea-a841-0242ac1c0004"
+        variable_name = "var1"
+        process_instance_var_url = \
+            f"{ENGINE_LOCAL_BASE_URL}/process-instance/{process_instance_id}/variables/{variable_name}"
+        resp_frame_payload = {"value": None, "valueInfo": {}, "type": ""}
+        resp_data_payload = base64.decodebytes(b"operaton")
+        process_instance_var_data_url = f"{process_instance_var_url}/data"
+
+        responses.add(responses.GET, process_instance_var_url, status=HTTPStatus.OK, json=resp_frame_payload)
+        responses.add(responses.GET, process_instance_var_data_url, status=HTTPStatus.OK, body=resp_data_payload)
+
+        resp = self.client.get_process_instance_variable(process_instance_id, variable_name, True)
+        self.assertEqual({"value": "operaton\n", "valueInfo": {}, "type": ""}, resp)

operaton/client/tests/test_external_task_client.py

@@ -0,0 +1,17 @@
+from unittest import TestCase
+
+from operaton.client.engine_client import ENGINE_LOCAL_BASE_URL
+from operaton.client.external_task_client import ExternalTaskClient
+
+
+class ExternalTaskClientTest(TestCase):
+
+    def test_creation_with_no_debug_config(self):
+        client = ExternalTaskClient(1, ENGINE_LOCAL_BASE_URL, {})
+        self.assertFalse(client.is_debug)
+        self.assertFalse(client.config.get("isDebug"))
+
+    def test_creation_with_debug_config(self):
+        client = ExternalTaskClient(1, ENGINE_LOCAL_BASE_URL, {"isDebug": True})
+        self.assertTrue(client.is_debug)
+        self.assertTrue(client.config.get("isDebug"))

operaton/client/tests/test_external_task_client_auth.py

@@ -0,0 +1,19 @@
+from unittest import TestCase
+
+from operaton.client.engine_client import ENGINE_LOCAL_BASE_URL
+from operaton.client.external_task_client import ExternalTaskClient
+
+
+class ExternalTaskClientTest(TestCase):
+
+    def test_auth_basic_creation_with_no_debug_config(self):
+        client = ExternalTaskClient(
+            1, ENGINE_LOCAL_BASE_URL, {"auth_basic": {"username": "demo", "password": "demo"}})
+        self.assertFalse(client.is_debug)
+        self.assertFalse(client.config.get("isDebug"))
+
+    def test_auth_basic_creation_with_debug_config(self):
+        client = ExternalTaskClient(
+            1, ENGINE_LOCAL_BASE_URL,{"auth_basic": {"username": "demo", "password": "demo"}, "isDebug": True})
+        self.assertTrue(client.is_debug)
+        self.assertTrue(client.config.get("isDebug"))

operaton/client/tests/test_external_task_client_bearer.py

@@ -0,0 +1,24 @@
+from unittest import TestCase
+
+from operaton.client.engine_client import ENGINE_LOCAL_BASE_URL
+from operaton.client.external_task_client import ExternalTaskClient
+
+
+class ExternalTaskClientTest(TestCase):
+
+    def test_auth_bearer_creation_with_no_debug_config(self):
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        client = ExternalTaskClient(
+            1, ENGINE_LOCAL_BASE_URL, {"auth_bearer": {"access_token": token}})
+        self.assertFalse(client.is_debug)
+        self.assertFalse(client.config.get("isDebug"))
+
+    def test_auth_bearer_creation_with_debug_config(self):
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        client = ExternalTaskClient(
+            1, ENGINE_LOCAL_BASE_URL,
+            {"auth_bearer": {"access_token": token}, "isDebug": True})
+        self.assertTrue(client.is_debug)
+        self.assertTrue(client.config.get("isDebug"))

operaton/external_task/async_external_task_executor.py

@@ -0,0 +1,91 @@
+import logging
+
+from operaton.client.async_external_task_client import AsyncExternalTaskClient
+from operaton.utils.log_utils import log_with_context
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncExternalTaskExecutor:
+
+    def __init__(self, worker_id: str, external_task_client: AsyncExternalTaskClient):
+        self.worker_id = worker_id
+        self.external_task_client = external_task_client
+
+    async def execute_task(self, task, action):
+        topic = task.get_topic_name()
+        task_id = task.get_task_id()
+        self._log_with_context(f"Executing external task for Topic: {topic}", task_id=task_id)
+        task_result = await action(task)
+        # in case task result is not set inside action function, set it in task here
+        task.set_task_result(task_result)
+        await self._handle_task_result(task_result)
+        return task_result
+
+    async def _handle_task_result(self, task_result):
+        task = task_result.get_task()
+        topic = task.get_topic_name()
+        task_id = task.get_task_id()
+        if task_result.is_success():
+            await self._handle_task_success(task_id, task_result, topic)
+        elif task_result.is_bpmn_error():
+            await self._handle_task_bpmn_error(task_id, task_result, topic)
+        elif task_result.is_failure():
+            await self._handle_task_failure(task_id, task_result, topic)
+        else:
+            err_msg = f"task result for task_id={task_id} must be either complete/failure/BPMNError"
+            self._log_with_context(err_msg, task_id=task_id, log_level='warning')
+            raise Exception(err_msg)
+
+    def _strip_long_variables(self, variables):
+        """remove value of complex variables for the dict"""
+        if not variables:
+            return variables
+        cleaned = {}
+        for k, v in variables.items():
+            if isinstance(v, dict) and v.get("type", "") in ("File", "Bytes"):
+                cleaned[k] = {**v, "value": "..."}
+            else:
+                cleaned[k] = v
+        return cleaned
+
+    async def _handle_task_success(self, task_id, task_result, topic):
+        self._log_with_context(f"Marking task complete for Topic: {topic}", task_id)
+        if await self.external_task_client.complete(task_id, task_result.global_variables, task_result.local_variables):
+            self._log_with_context(f"Marked task completed - Topic: {topic} "
+                                   f"global_variables: {self._strip_long_variables(task_result.global_variables)} "
+                                   f"local_variables: {self._strip_long_variables(task_result.local_variables)}",
+                                   task_id, log_level='debug')
+        else:
+            self._log_with_context(f"Not able to mark task completed - Topic: {topic} "
+                                   f"global_variables: {self._strip_long_variables(task_result.global_variables)} "
+                                   f"local_variables: {self._strip_long_variables(task_result.local_variables)}",
+                                   task_id, log_level='error')
+            raise Exception(f"Not able to mark complete for task_id={task_id} "
+                            f"for topic={topic}, worker_id={self.worker_id}")
+
+    async def _handle_task_failure(self, task_id, task_result, topic):
+        self._log_with_context(f"Marking task failed - Topic: {topic} task_result: {task_result}", task_id)
+        if await self.external_task_client.failure(task_id, task_result.error_message, task_result.error_details,
+                                                   task_result.retries, task_result.retry_timeout):
+            self._log_with_context(f"Marked task failed - Topic: {topic} task_result: {task_result}", task_id)
+        else:
+            self._log_with_context(f"Not able to mark task failure - Topic: {topic}", task_id=task_id)
+            raise Exception(f"Not able to mark failure for task_id={task_id} "
+                            f"for topic={topic}, worker_id={self.worker_id}")
+
+    async def _handle_task_bpmn_error(self, task_id, task_result, topic):
+        bpmn_error_handled = await self.external_task_client.bpmn_failure(task_id, task_result.bpmn_error_code,
+                                                                          task_result.error_message,
+                                                                          task_result.global_variables)
+        if bpmn_error_handled:
+            self._log_with_context(f"BPMN Error Handled: {bpmn_error_handled} "
+                                   f"Topic: {topic} task_result: {task_result}")
+        else:
+            self._log_with_context(f"Not able to mark BPMN error - Topic: {topic}", task_id=task_id)
+            raise Exception(f"Not able to mark BPMN Error for task_id={task_id} "
+                            f"for topic={topic}, worker_id={self.worker_id}")
+
+    def _log_with_context(self, msg, task_id=None, log_level='info', **kwargs):
+        context = {"WORKER_ID": self.worker_id, "TASK_ID": task_id}
+        log_with_context(msg, context=context, log_level=log_level, **kwargs)

operaton/external_task/async_external_task_worker.py

@@ -0,0 +1,181 @@
+import asyncio
+from typing import Any, Callable, Dict, List, Optional
+
+from operaton.client.async_external_task_client import AsyncExternalTaskClient
+from operaton.client.external_task_client import ENGINE_LOCAL_BASE_URL
+from operaton.external_task.async_external_task_executor import AsyncExternalTaskExecutor
+from operaton.external_task.external_task import ExternalTask
+from operaton.utils.auth_basic import obfuscate_password
+from operaton.utils.log_utils import log_with_context
+from operaton.utils.utils import get_exception_detail
+
+
+class AsyncExternalTaskWorker:
+    DEFAULT_SLEEP_SECONDS = 1  # Sleep duration when no tasks are fetched
+
+    def __init__(
+        self,
+        worker_id: str,
+        base_url: str = ENGINE_LOCAL_BASE_URL,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        self.config = config or {}
+        self.worker_id = worker_id
+        self.client = AsyncExternalTaskClient(self.worker_id, base_url, self.config)
+        self.executor = AsyncExternalTaskExecutor(self.worker_id, self.client)
+        self.subscriptions: List[asyncio.Task] = []
+        max_concurrent_tasks = self.config.get('maxConcurrentTasks', 10)
+        self.semaphore = asyncio.Semaphore(max_concurrent_tasks)
+        self.running_tasks = set()
+        self._log_with_context(
+            f"Created new External Task Worker with config: {obfuscate_password(self.config)}"
+        )
+
+    async def subscribe(
+        self,
+        topic_handlers: Dict[str, Callable[[ExternalTask], Any]],
+        process_variables: Optional[Dict[str, Any]] = None,
+        variables: Optional[List[str]] = None,
+    ):
+        self.subscriptions = [
+            asyncio.create_task(
+                self._fetch_and_execute_safe(topic, action, process_variables, variables)
+            )
+            for topic, action in topic_handlers.items()
+        ]
+        await asyncio.gather(*self.subscriptions)
+
+    async def _fetch_and_execute_safe(
+        self,
+        topic_name: str,
+        action: Callable[[ExternalTask], Any],
+        process_variables: Optional[Dict[str, Any]] = None,
+        variables: Optional[List[str]] = None,
+    ):
+        sleep_seconds = self._get_sleep_seconds()
+        while True:
+            try:
+                await self.semaphore.acquire()
+                tasks_processed = await self.fetch_and_execute(topic_name, action, process_variables, variables)
+                if not tasks_processed:
+                    # Release semaphore if no tasks were fetched
+                    self.semaphore.release()
+                    await asyncio.sleep(sleep_seconds)
+                else:
+                    await asyncio.sleep(0)  # Yield control to the event loop
+            except asyncio.CancelledError:
+                self._log_with_context(f"Task for topic {topic_name} was cancelled.")
+                break
+            except Exception as e:
+                self._log_with_context(
+                    f"Error fetching and executing tasks: {get_exception_detail(e)} "
+                    f"for topic={topic_name} with Process variables: {process_variables}. "
+                    f"Retrying after {sleep_seconds} seconds",
+                    exc_info=True,
+                    log_level="error"
+                )
+                self.semaphore.release()
+                await asyncio.sleep(sleep_seconds)
+
+    async def fetch_and_execute(
+        self,
+        topic_name: str,
+        action: Callable[[ExternalTask], Any],
+        process_variables: Optional[Dict[str, Any]] = None,
+        variables: Optional[List[str]] = None,
+    ):
+        self._log_with_context(
+            f"Fetching and executing external tasks for Topic: {topic_name} "
+            f"with Process variables: {process_variables}",
+            log_level="debug"
+        )
+        resp_json = await self.client.fetch_and_lock([topic_name], process_variables, variables)
+        tasks = self._parse_response(resp_json, topic_name, process_variables)
+        if not tasks:
+            return False
+
+        for task in tasks:
+            # Start processing the task in the background
+            running_task = asyncio.create_task(self._execute_task(task, action))
+            self.running_tasks.add(running_task)
+            # Release semaphore when task is done
+            running_task.add_done_callback(lambda t: self.semaphore.release())
+            # Remove from running_tasks when done
+            running_task.add_done_callback(self.running_tasks.discard)
+        return True
+
+    def _parse_response(
+        self,
+        resp_json: List[Dict[str, Any]],
+        topic_name: str,
+        process_variables: Optional[Dict[str, Any]],
+    ) -> List[ExternalTask]:
+        tasks = [ExternalTask(context) for context in resp_json or []]
+        tasks_count = len(tasks)
+        self._log_with_context(
+            f"{tasks_count} external task(s) found for "
+            f"Topic: {topic_name}, Process variables: {process_variables}",
+            log_level="debug"
+        )
+        return tasks
+
+    async def _execute_task(self, task: ExternalTask, action: Callable[[ExternalTask], Any]):
+        try:
+            await self.executor.execute_task(task, action)
+        except asyncio.CancelledError:
+            task_result = task.failure(
+                error_message='Task execution cancelled',
+                error_details='Task was cancelled by the user or system',
+                max_retries=self.config.get('retries', AsyncExternalTaskClient.default_config['retries']),
+                retry_timeout=self.config.get('retryTimeout', AsyncExternalTaskClient.default_config['retryTimeout'])
+            )
+            await self.executor._handle_task_result(task_result)
+            self._log_with_context(
+                f"Task execution cancelled for task_id: {task.get_task_id()}",
+                topic=task.get_topic_name(),
+                task_id=task.get_task_id(),
+                log_level="info"
+            )
+            return task_result
+        except Exception as e:
+            task_result = task.failure(
+                error_message='Task execution failed',
+                error_details='An unexpected error occurred while executing the task',
+                max_retries=self.config.get('retries', AsyncExternalTaskClient.default_config['retries']),
+                retry_timeout=self.config.get('retryTimeout', AsyncExternalTaskClient.default_config['retryTimeout'])
+            )
+            await self.executor._handle_task_result(task_result)
+            self._log_with_context(
+                f"Error when executing task: {get_exception_detail(e)}. "
+                f"Task execution cancelled for task_id: {task.get_task_id()}.",
+                topic=task.get_topic_name(),
+                task_id=task.get_task_id(),
+                log_level="error",
+                exc_info=True
+            )
+            return task_result
+
+    def _log_with_context(
+        self,
+        msg: str,
+        topic: Optional[str] = None,
+        task_id: Optional[str] = None,
+        log_level: str = "info",
+        **kwargs: Any,
+    ):
+        context = {"WORKER_ID": str(self.worker_id), "TOPIC": topic, "TASK_ID": task_id}
+        log_with_context(msg, context=context, log_level=log_level, **kwargs)
+
+    def _get_sleep_seconds(self) -> int:
+        return self.config.get("sleepSeconds", self.DEFAULT_SLEEP_SECONDS)
+
+    async def stop(self):
+        # First, cancel running tasks
+        for task in self.running_tasks:
+            task.cancel()
+        await asyncio.gather(*self.running_tasks, return_exceptions=True)
+
+        # Then, cancel the fetch loops (subscriptions)
+        for task in self.subscriptions:
+            task.cancel()
+        await asyncio.gather(*self.subscriptions, return_exceptions=True)