boilermaker-servicebus 1.0.0.dev2__tar.gz → 1.0.0.dev5__tar.gz

{boilermaker_servicebus-1.0.0.dev2 → boilermaker_servicebus-1.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boilermaker-servicebus
-Version: 1.0.0.dev2
+Version: 1.0.0.dev5
 Summary: An async python Background task system using Azure Service Bus Queues
 Author-email: Erik Aker <eaker@mulliganfunding.com>
 License:                                  Apache License
@@ -210,7 +210,7 @@ Project-URL: Issues, https://github.com/MulliganFunding/boilermaker-servicebus/i
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aio-azure-clients-toolbox>=1.0.4
+Requires-Dist: aio-azure-clients-toolbox>=1.1.0
 Requires-Dist: anyio>=4.11.0
 Requires-Dist: azure-core-tracing-opentelemetry>=1.0.0b12
 Requires-Dist: azure-servicebus>=7.14.2
@@ -219,6 +219,8 @@ Requires-Dist: opentelemetry-api>=1.34.0
 Requires-Dist: pydantic>=2.12.2
 Requires-Dist: pydantic-settings>=2.11.0
 Requires-Dist: uuid-utils>=0.11.1
+Provides-Extra: repl
+Requires-Dist: ipython; extra == "repl"
 Dynamic: license-file
 
 # Boilermaker

{boilermaker_servicebus-1.0.0.dev2 → boilermaker_servicebus-1.0.0.dev5}/boilermaker/app.py

@@ -12,7 +12,7 @@ import typing
 import weakref
 from functools import wraps
 
-from aio_azure_clients_toolbox import AzureServiceBus, ManagedAzureServiceBusSender  # type: ignore
+from aio_azure_clients_toolbox import AzureServiceBus, ManagedAzureServiceBusSender
 from anyio import create_task_group, open_signal_receiver
 from anyio.abc import CancelScope
 from azure.servicebus import ServiceBusReceivedMessage
@@ -163,7 +163,7 @@ class Boilermaker:
             raise ValueError(f"Function must be async: {fn_name}")
 
         task = Task.default(fn_name, **options)
-        self.function_registry[fn_name] = fn
+        self.function_registry[fn_name] = typing.cast(TaskHandler, fn)  # why must cast here
         self.task_registry[fn_name] = task
         logger.info(f"Registered background function fn={fn_name}")
         return self
@@ -322,9 +322,7 @@ class Boilermaker:
             await app.apply_async(cleanup_temp_files, delay=300)
         """
         task = self.create_task(fn, *args, policy=policy, **kwargs)
-        return await self.publish_task(
-            task, delay=delay, publish_attempts=publish_attempts
-        )
+        return await self.publish_task(task, delay=delay, publish_attempts=publish_attempts)
 
     @tracer.start_as_current_span("boilermaker.publish-task")
     async def publish_task(
@@ -361,13 +359,12 @@ class Boilermaker:
                 results: list[int] = await self.service_bus_client.send_message(
                     task.model_dump_json(),
                     delay=delay,
+                    unique_msg_id=str(task.task_id),
                 )
                 if results and len(results) == 1:
                     sequence_number = results[0]
                     task.mark_published(sequence_number)
-                    logger.debug(
-                        f"Published task {task.task_id} to queue with sequence_number={sequence_number}"
-                    )
+                    logger.debug(f"Published task {task.task_id} to queue with sequence_number={sequence_number}")
                 return task
 
             except (
@@ -406,6 +403,13 @@ class Boilermaker:
                     [f"Expected graph_id={graph.graph_id}, found {task.graph_id=}"],
                 )
 
+        for task in graph.fail_children.values():
+            if task.graph_id != graph.graph_id:
+                raise BoilermakerAppException(
+                    "All failure callback tasks must have graph_id matching graph",
+                    [f"Expected graph_id={graph.graph_id}, found {task.graph_id=}"],
+                )
+
         # Store the graph definition and all pending task results
         # If this graph has already been stored, this should fail.
         try:
@@ -413,8 +417,34 @@ class Boilermaker:
         except BoilermakerStorageError as exc:
             raise BoilermakerAppException("Error storing TaskGraph to storage", [str(exc)]) from exc
 
-        # Publish all ready tasks (should be root nodes with no dependencies)
-        for task in graph.generate_ready_tasks():
+        # Reload to get ETags on pending result blobs (required for ETag-guarded Scheduled writes)
+        try:
+            loaded_graph = await self.results_storage.load_graph(graph.graph_id)
+        except BoilermakerStorageError as exc:
+            raise BoilermakerAppException("Error loading TaskGraph after storage", [str(exc)]) from exc
+
+        if not loaded_graph:
+            raise BoilermakerAppException("TaskGraph not found after storing — this should not happen", [])
+
+        # Publish root tasks with ETag-guarded Scheduled write (same protocol as continue_graph)
+        for task in loaded_graph.generate_ready_tasks():
+            try:
+                result = loaded_graph.schedule_task(task.task_id)
+                await self.results_storage.store_task_result(result, etag=result.etag)
+            except BoilermakerStorageError:
+                logger.error(
+                    f"Failed to write Scheduled status for root task {task.task_id} in graph "
+                    f"{graph.graph_id}. Not publishing to avoid inconsistent state.",
+                    exc_info=True,
+                )
+                continue
+            except ValueError:
+                logger.error(
+                    f"schedule_task raised ValueError for root task {task.task_id} in graph "
+                    f"{graph.graph_id}. Skipping.",
+                    exc_info=True,
+                )
+                continue
             await self.publish_task(task)
 
         return graph

{boilermaker_servicebus-1.0.0.dev2 → boilermaker_servicebus-1.0.0.dev5}/boilermaker/evaluators/__init__.py

@@ -4,12 +4,11 @@ import typing
 from azure.servicebus.aio import ServiceBusReceiver
 
 from boilermaker.storage.base import StorageInterface
-from boilermaker.task import Task
+from boilermaker.task import Task, TaskHandler
 
 from .common import (
     MessageActions,
     TaskEvaluatorBase,
-    TaskHandler,
     TaskHandlerRegistry,
     TaskPublisher,
 )

{boilermaker_servicebus-1.0.0.dev2 → boilermaker_servicebus-1.0.0.dev5}/boilermaker/evaluators/common.py

@@ -3,7 +3,7 @@ import logging
 import traceback
 import typing
 from abc import abstractmethod
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable
 from functools import cached_property
 from json.decoder import JSONDecodeError
 
@@ -21,14 +21,12 @@ from pydantic import ValidationError
 from boilermaker import exc, sample
 from boilermaker.storage import StorageInterface
 from boilermaker.task import Task, TaskResult, TaskStatus
+from boilermaker.task import types as task_types
 
 tracer: trace.Tracer = trace.get_tracer(__name__)
 logger = logging.getLogger("boilermaker.app")
 
-
-# Common Types used when evaluating tasks
-TaskHandler: typing.TypeAlias = Callable[..., Awaitable[typing.Any]]
-TaskHandlerRegistry: typing.TypeAlias = dict[str, TaskHandler]
+TaskHandlerRegistry: typing.TypeAlias = dict[str, task_types.TaskHandler]
 
 
 class TaskPublisher(typing.Protocol):
@@ -52,9 +50,7 @@ class MessageActions:
     """
 
     @classmethod
-    async def task_decoder(
-        cls, msg: ServiceBusReceivedMessage, receiver: ServiceBusReceiver
-    ) -> Task | None:
+    async def task_decoder(cls, msg: ServiceBusReceivedMessage, receiver: ServiceBusReceiver) -> Task | None:
         """Decode a ServiceBusReceivedMessage into a Task."""
         try:
             task = Task.model_validate_json(str(msg))
@@ -62,10 +58,7 @@ class MessageActions:
             return task
         except (JSONDecodeError, ValidationError):
             # This task is not parseable
-            log_err_msg = (
-                f"Invalid task sequence_number={msg.sequence_number} "
-                f"exc_info={traceback.format_exc()}"
-            )
+            log_err_msg = f"Invalid task sequence_number={msg.sequence_number} exc_info={traceback.format_exc()}"
             logger.error(log_err_msg)
             await receiver.dead_letter_message(
                 msg,
@@ -75,17 +68,13 @@ class MessageActions:
             return None
 
     @staticmethod
-    async def abandon_message(
-        msg: ServiceBusReceivedMessage, receiver: ServiceBusReceiver
-    ) -> None:
+    async def abandon_message(msg: ServiceBusReceivedMessage, receiver: ServiceBusReceiver) -> None:
         """Abandon the message being processed."""
         if msg is not None:
             sequence_number = msg.sequence_number
             try:
                 await receiver.abandon_message(msg)
-                logger.warning(
-                    f"Abandoning message: returned to queue {sequence_number=}"
-                )
+                logger.warning(f"Abandoning message: returned to queue {sequence_number=}")
             except (
                 MessageAlreadySettled,
                 MessageLockLostError,
@@ -95,18 +84,13 @@ class MessageActions:
                 logger.error(err_msg)
                 raise exc.BoilermakerTaskLeaseLost(err_msg) from None
             except ServiceBusError as sb_exc:
-                err_msg = (
-                    f"ServiceBusError requeuing message {sequence_number=} "
-                    f"exc_info={traceback.format_exc()}"
-                )
+                err_msg = f"ServiceBusError requeuing message {sequence_number=} exc_info={traceback.format_exc()}"
                 logger.error(err_msg)
                 raise exc.BoilermakerServiceBusError(err_msg) from sb_exc
         return None
 
     @staticmethod
-    async def complete_message(
-        msg: ServiceBusReceivedMessage, receiver: ServiceBusReceiver
-    ):
+    async def complete_message(msg: ServiceBusReceivedMessage, receiver: ServiceBusReceiver):
         """Complete the current message being processed."""
         try:
             await receiver.complete_message(msg)
@@ -115,10 +99,7 @@ class MessageActions:
             MessageLockLostError,
             SessionLockLostError,
         ):
-            logmsg = (
-                f"Failed to settle message sequence_number={msg.sequence_number} "
-                f"exc_info={traceback.format_exc()}"
-            )
+            logmsg = f"Failed to settle message sequence_number={msg.sequence_number} exc_info={traceback.format_exc()}"
             logger.error(logmsg)
             raise exc.BoilermakerTaskLeaseLost(msg) from None
         except ServiceBusError as sb_exc:
@@ -150,8 +131,7 @@ class MessageActions:
             SessionLockLostError,
         ):
             logmsg = (
-                f"Failed to deadletter message sequence_number={msg.sequence_number} "
-                f"exc_info={traceback.format_exc()}"
+                f"Failed to deadletter message sequence_number={msg.sequence_number} exc_info={traceback.format_exc()}"
             )
             logger.error(logmsg)
             raise exc.BoilermakerTaskLeaseLost(logmsg) from None
@@ -180,8 +160,7 @@ class MessageActions:
             return await receiver.renew_message_lock(msg)
         except (MessageLockLostError, MessageAlreadySettled, SessionLockLostError):
             logmsg = (
-                f"Failed to renew message lock sequence_number={msg.sequence_number} "
-                f"exc_info={traceback.format_exc()}"
+                f"Failed to renew message lock sequence_number={msg.sequence_number} exc_info={traceback.format_exc()}"
             )
             logger.error(logmsg)
             raise exc.BoilermakerTaskLeaseLost(logmsg) from None
@@ -203,9 +182,7 @@ class MessageActions:
     ):
         """Deadletter or complete the current task based on its configuration."""
         if task.msg is None:
-            logger.warning(
-                "No current message to settle for deadletter_or_complete_task"
-            )
+            logger.warning("No current message to settle for deadletter_or_complete_task")
             return None
 
         if task.should_dead_letter:
@@ -272,22 +249,16 @@ class TaskEvaluatorBase:
     # Message handling actions
     async def abandon_current_message(self) -> None:
         if self.current_msg is not None:
-            return await MessageActions.abandon_message(
-                self.current_msg, self._receiver
-            )
+            return await MessageActions.abandon_message(self.current_msg, self._receiver)
 
     async def complete_message(self) -> None:
         if self.current_msg is not None:
-            return await MessageActions.complete_message(
-                self.current_msg, self._receiver
-            )
+            return await MessageActions.complete_message(self.current_msg, self._receiver)
 
     async def renew_message_lock(self) -> datetime.datetime | None:
         """Renew the lock on the current message being processed."""
         if self.current_msg is not None:
-            return await MessageActions.renew_message_lock(
-                self.current_msg, self._receiver
-            )
+            return await MessageActions.renew_message_lock(self.current_msg, self._receiver)
         return None
 
     async def deadletter_or_complete_task(
@@ -295,9 +266,7 @@ class TaskEvaluatorBase:
         reason: str,
         detail: Exception | str | None = None,
     ) -> None:
-        return await MessageActions.deadletter_or_complete_task(
-            self.task, self._receiver, reason, detail=detail
-        )
+        return await MessageActions.deadletter_or_complete_task(self.task, self._receiver, reason, detail=detail)
 
     async def __call__(self) -> TaskResult | None:
         """Call pre-processing hook and then `message_handler`."""
@@ -306,9 +275,7 @@ class TaskEvaluatorBase:
             if not await self.pre_process():
                 return None
         except exc.BoilermakerUnregisteredFunction:
-            await self.deadletter_or_complete_task(
-                "ExpectationFailed", detail="Pre-processing expectation failed"
-            )
+            await self.deadletter_or_complete_task("ExpectationFailed", detail="Pre-processing expectation failed")
             return TaskResult(
                 task_id=self.task.task_id,
                 graph_id=self.task.graph_id,
@@ -318,9 +285,7 @@ class TaskEvaluatorBase:
             )
         except Exception:
             logger.error("Exception in pre_process", exc_info=True)
-            await self.deadletter_or_complete_task(
-                "ProcessingError", detail="Pre-processing exception"
-            )
+            await self.deadletter_or_complete_task("ProcessingError", detail="Pre-processing exception")
             return TaskResult(
                 task_id=self.task.task_id,
                 graph_id=self.task.graph_id,
@@ -351,7 +316,5 @@ class TaskEvaluatorBase:
             return False
 
         if not self.function_registry.get(self.task.function_name):
-            raise exc.BoilermakerUnregisteredFunction(
-                f"Missing registered function {self.task.function_name}"
-            )
+            raise exc.BoilermakerUnregisteredFunction(f"Missing registered function {self.task.function_name}")
         return True

{boilermaker_servicebus-1.0.0.dev2 → boilermaker_servicebus-1.0.0.dev5}/boilermaker/evaluators/eval.py

@@ -7,8 +7,7 @@ from boilermaker.exc import BoilermakerUnregisteredFunction
 from boilermaker.failure import TaskFailureResult
 from boilermaker.retries import RetryException
 from boilermaker.task import Task, TaskResult, TaskStatus
-
-from .common import TaskHandler
+from boilermaker.task.types import TaskHandler
 
 logger = logging.getLogger("boilermaker.app")
 
@@ -45,9 +44,7 @@ async def eval_task(
     logger.info(f"[{task.function_name}] Begin Task {task.sequence_number=}")
 
     if function is None:
-        raise BoilermakerUnregisteredFunction(
-            f"Function {task.function_name} not found in registry"
-        )
+        raise BoilermakerUnregisteredFunction(f"Function {task.function_name} not found in registry")
 
     try:
         result = await function(
@@ -78,8 +75,7 @@ async def eval_task(
                 status=TaskStatus.Success,
             )
             logger.info(
-                f"[{task.function_name}] Completed Task {task.sequence_number=} "
-                f"in {time.monotonic() - start:.3f}s"
+                f"[{task.function_name}] Completed Task {task.sequence_number=} in {time.monotonic() - start:.3f}s"
             )
     except RetryException as retry:
         # A retry has been requested:

{boilermaker_servicebus-1.0.0.dev2 → boilermaker_servicebus-1.0.0.dev5}/boilermaker/evaluators/results_store.py

@@ -62,9 +62,7 @@ class ResultsStorageTaskEvaluator(TaskEvaluatorBase):
                 await self.complete_message()
                 message_settled = True
             except exc.BoilermakerTaskLeaseLost:
-                logger.error(
-                    f"Lost message lease when trying to complete early for task {self.task.function_name}"
-                )
+                logger.error(f"Lost message lease when trying to complete early for task {self.task.function_name}")
                 return TaskResult(
                     task_id=self.task.task_id,
                     graph_id=self.task.graph_id,
@@ -89,8 +87,7 @@ class ResultsStorageTaskEvaluator(TaskEvaluatorBase):
                     message_settled = True
                 except exc.BoilermakerTaskLeaseLost:
                     logger.error(
-                        f"Lost message lease when trying to deadletter/complete "
-                        f" for task {self.task.function_name}"
+                        f"Lost message lease when trying to deadletter/complete  for task {self.task.function_name}"
                     )
                     return TaskResult(
                         task_id=self.task.task_id,

{boilermaker_servicebus-1.0.0.dev2 → boilermaker_servicebus-1.0.0.dev5}/boilermaker/evaluators/simple.py

@@ -45,9 +45,7 @@ class NoStorageEvaluator(TaskEvaluatorBase):
                 await self.complete_message()
                 message_settled = True
             except exc.BoilermakerTaskLeaseLost:
-                logger.error(
-                    f"Lost message lease when trying to complete early for task {self.task.function_name}"
-                )
+                logger.error(f"Lost message lease when trying to complete early for task {self.task.function_name}")
                 return TaskResult(
                     task_id=self.task.task_id,
                     graph_id=self.task.graph_id,
@@ -71,8 +69,7 @@ class NoStorageEvaluator(TaskEvaluatorBase):
                     message_settled = True
                 except exc.BoilermakerTaskLeaseLost:
                     logger.error(
-                        f"Lost message lease when trying to deadletter/complete "
-                        f" for task {self.task.function_name}"
+                        f"Lost message lease when trying to deadletter/complete  for task {self.task.function_name}"
                     )
                     return TaskResult(
                         task_id=self.task.task_id,