update-with-start examples

dandavison · dandavison · commit 07bdc7c9b39d · 2024-10-28T11:20:47.000-04:00
diff --git a/message_passing/update_with_start/__init__.py b/message_passing/update_with_start/__init__.py
@@ -0,0 +1 @@
+TASK_QUEUE = "uws"
diff --git a/message_passing/update_with_start/starter.py b/message_passing/update_with_start/starter.py
@@ -0,0 +1,58 @@
+import asyncio
+
+from temporalio.client import Client
+
+from message_passing.update_with_start import TASK_QUEUE
+from message_passing.update_with_start.workflows import (
+    LockService,
+    TransactionRequest,
+    TransactionWorkflow,
+)
+
+
+async def financial_transaction_with_early_return():
+    client = await Client.connect("localhost:7233")
+    # The user wants to kick off a long-running transaction workflow and get an early-return result.
+
+    # No network call here
+    transaction = client.start_workflow(
+        TransactionWorkflow.run,
+        args=[TransactionRequest(amount=77.7)],
+        id="transaction-abc123",
+        task_queue=TASK_QUEUE,
+        lazy=True,
+    )
+
+    # Send the MultiOp gRPC
+    confirmation_token = await transaction.execute_update(
+        TransactionWorkflow.get_confirmation
+    )
+    final_report = await transaction.result()
+
+    print(f"got confirmation token: {confirmation_token}")
+    print(f"got final report: {final_report}")
+
+
+async def use_a_lock_service():
+    client = await Client.connect("localhost:7233")
+
+    # The user wants to acquire a lock lease from a lock service
+
+    lock_service = client.start_workflow(
+        LockService.run,
+        id="lock-service-id",
+        task_queue="uws",
+        lazy=True,
+    )
+
+    lock = await lock_service.execute_update(LockService.acquire_lock)
+    print(f"acquired lock: {lock}")
+
+
+async def main():
+    await financial_transaction_with_early_return()
+    await use_a_lock_service()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/message_passing/update_with_start/worker.py b/message_passing/update_with_start/worker.py
@@ -0,0 +1,33 @@
+import asyncio
+import logging
+
+from temporalio.client import Client
+from temporalio.worker import Worker
+
+from message_passing.update_with_start import TASK_QUEUE, workflows
+
+interrupt_event = asyncio.Event()
+
+
+async def main():
+    logging.basicConfig(level=logging.INFO)
+
+    client = await Client.connect("localhost:7233")
+
+    async with Worker(
+        client,
+        task_queue=TASK_QUEUE,
+        workflows=[workflows.LockService, workflows.TransactionWorkflow],
+    ):
+        logging.info("Worker started, ctrl+c to exit")
+        await interrupt_event.wait()
+        logging.info("Shutting down")
+
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    try:
+        loop.run_until_complete(main())
+    except KeyboardInterrupt:
+        interrupt_event.set()
+        loop.run_until_complete(loop.shutdown_asyncgens())
diff --git a/message_passing/update_with_start/workflows.py b/message_passing/update_with_start/workflows.py
@@ -0,0 +1,76 @@
+from asyncio import Future
+from dataclasses import dataclass
+from typing import Literal
+from uuid import uuid4
+
+from temporalio import workflow
+
+#
+# LockService (lazy init)
+# A workflow acts as an always-available service and supports an `acquire_lock` update.
+#
+
+
+@dataclass
+class Lock:
+    token: str
+
+
+@workflow.defn
+class LockService:
+    @workflow.run
+    async def run(self) -> None:
+        await Future()
+
+    @workflow.update
+    async def acquire_lock(self) -> Lock:
+        # TODO: implement lock service sample
+        token = str(uuid4())
+        return Lock(token)
+
+
+#
+# FinancialTransaction (early return)
+# The workflow is a multi-stage financial transaction and supports a low-latency `get_confirmation` update.
+#
+
+
+@dataclass
+class TransactionRequest:
+    amount: float
+
+
+@dataclass
+class TransactionReport:
+    id: str
+    final_amount: float
+    status: Literal["complete", "failed"]
+
+
+@dataclass
+class TransactionConfirmation:
+    id: str
+    status: Literal["confirmed"]
+
+
+@workflow.defn
+class TransactionWorkflow:
+    def __init__(self):
+        self.ready_to_issue_final_report = False
+
+    @workflow.run
+    async def run(self, request: TransactionRequest) -> TransactionReport:
+        await workflow.wait_condition(lambda: self.ready_to_issue_final_report)
+        return TransactionReport(
+            id=workflow.info().workflow_id,
+            status="complete",
+            final_amount=request.amount * 0.97,
+        )
+
+    @workflow.update
+    async def get_confirmation(self) -> TransactionConfirmation:
+        self.ready_to_issue_final_report = True
+        return TransactionConfirmation(
+            id=workflow.info().workflow_id,
+            status="confirmed",
+        )
