Quickstart: Workflow

Get started with the Dapr Workflow building block

Note

Dapr Workflow is currently in beta. See known limitations for 1.12.0.

Let’s take a look at the Dapr Workflow building block. In this Quickstart, you’ll create a simple console application to demonstrate Dapr’s workflow programming model and the workflow management APIs.

In this guide, you’ll:

  • Run the order-processor application.
  • Start the workflow and watch the workflow activites/tasks execute.
  • Review the workflow logic and the workflow activities and how they’re represented in the code.

Workflow - 图1

The order-processor console app starts and manages the order_processing_workflow, which simulates purchasing items from a store. The workflow consists of five unique workflow activities, or tasks:

  • notify_activity: Utilizes a logger to print out messages throughout the workflow. These messages notify you when:
    • You have insufficient inventory
    • Your payment couldn’t be processed, etc.
  • process_payment_activity: Processes and authorizes the payment.
  • verify_inventory_activity: Checks the state store to ensure there is enough inventory present for purchase.
  • update_inventory_activity: Removes the requested items from the state store and updates the store with the new remaining inventory value.
  • request_approval_activity: Seeks approval from the manager if payment is greater than 50,000 USD.

Step 1: Pre-requisites

For this example, you will need:

Step 2: Set up the environment

Clone the sample provided in the Quickstarts repo.

  1. git clone https://github.com/dapr/quickstarts.git

In a new terminal window, navigate to the order-processor directory:

  1. cd workflows/python/sdk/order-processor

Install the Dapr Python SDK package:

  1. pip3 install -r requirements.txt

Step 3: Run the order processor app

In the terminal, start the order processor app alongside a Dapr sidecar:

  1. dapr run --app-id order-processor --resources-path ../../../components/ -- python3 app.py

Note: Since Python3.exe is not defined in Windows, you may need to use python app.py instead of python3 app.py.

This starts the order-processor app with unique workflow ID and runs the workflow activities.

Expected output:

  1. == APP == Starting order workflow, purchasing 10 of cars
  2. == APP == 2023-06-06 09:35:52.945 durabletask-worker INFO: Successfully connected to 127.0.0.1:65406. Waiting for work items...
  3. == APP == INFO:NotifyActivity:Received order f4e1926e-3721-478d-be8a-f5bebd1995da for 10 cars at $150000 !
  4. == APP == INFO:VerifyInventoryActivity:Verifying inventory for order f4e1926e-3721-478d-be8a-f5bebd1995da of 10 cars
  5. == APP == INFO:VerifyInventoryActivity:There are 100 Cars available for purchase
  6. == APP == INFO:RequestApprovalActivity:Requesting approval for payment of 165000 USD for 10 cars
  7. == APP == 2023-06-06 09:36:05.969 durabletask-worker INFO: f4e1926e-3721-478d-be8a-f5bebd1995da Event raised: manager_approval
  8. == APP == INFO:NotifyActivity:Payment for order f4e1926e-3721-478d-be8a-f5bebd1995da has been approved!
  9. == APP == INFO:ProcessPaymentActivity:Processing payment: f4e1926e-3721-478d-be8a-f5bebd1995da for 10 cars at 150000 USD
  10. == APP == INFO:ProcessPaymentActivity:Payment for request ID f4e1926e-3721-478d-be8a-f5bebd1995da processed successfully
  11. == APP == INFO:UpdateInventoryActivity:Checking inventory for order f4e1926e-3721-478d-be8a-f5bebd1995da for 10 cars
  12. == APP == INFO:UpdateInventoryActivity:There are now 90 cars left in stock
  13. == APP == INFO:NotifyActivity:Order f4e1926e-3721-478d-be8a-f5bebd1995da has completed!
  14. == APP == 2023-06-06 09:36:06.106 durabletask-worker INFO: f4e1926e-3721-478d-be8a-f5bebd1995da: Orchestration completed with status: COMPLETED
  15. == APP == Workflow completed! Result: Completed
  16. == APP == Purchase of item is  Completed

(Optional) Step 4: View in Zipkin

Running dapr init launches the openzipkin/zipkin Docker container. If the container has stopped running, launch the Zipkin Docker container with the following command:

  1. docker run -d -p 9411:9411 openzipkin/zipkin

View the workflow trace spans in the Zipkin web UI (typically at http://localhost:9411/zipkin/).

Workflow - 图2

What happened?

When you ran dapr run --app-id order-processor --resources-path ../../../components/ -- python3 app.py:

  1. A unique order ID for the workflow is generated (in the above example, f4e1926e-3721-478d-be8a-f5bebd1995da) and the workflow is scheduled.
  2. The NotifyActivity workflow activity sends a notification saying an order for 10 cars has been received.
  3. The ReserveInventoryActivity workflow activity checks the inventory data, determines if you can supply the ordered item, and responds with the number of cars in stock.
  4. Your workflow starts and notifies you of its status.
  5. The ProcessPaymentActivity workflow activity begins processing payment for order f4e1926e-3721-478d-be8a-f5bebd1995da and confirms if successful.
  6. The UpdateInventoryActivity workflow activity updates the inventory with the current available cars after the order has been processed.
  7. The NotifyActivity workflow activity sends a notification saying that order f4e1926e-3721-478d-be8a-f5bebd1995da has completed.
  8. The workflow terminates as completed.

order-processor/app.py

In the application’s program file:

  • The unique workflow order ID is generated
  • The workflow is scheduled
  • The workflow status is retrieved
  • The workflow and the workflow activities it invokes are registered
  1. class WorkflowConsoleApp:    
  2.     def main(self):
  3.         # Register workflow and activities
  4.         workflowRuntime = WorkflowRuntime(settings.DAPR_RUNTIME_HOST, settings.DAPR_GRPC_PORT)
  5.         workflowRuntime.register_workflow(order_processing_workflow)
  6.         workflowRuntime.register_activity(notify_activity)
  7.         workflowRuntime.register_activity(requst_approval_activity)
  8.         workflowRuntime.register_activity(verify_inventory_activity)
  9.         workflowRuntime.register_activity(process_payment_activity)
  10.         workflowRuntime.register_activity(update_inventory_activity)
  11.         workflowRuntime.start()
  13.         print("==========Begin the purchase of item:==========", flush=True)
  14.         item_name = default_item_name
  15.         order_quantity = 10
  17.         total_cost = int(order_quantity) * baseInventory[item_name].per_item_cost
  18.         order = OrderPayload(item_name=item_name, quantity=int(order_quantity), total_cost=total_cost)
  20.         # Start Workflow
  21.         print(f'Starting order workflow, purchasing {order_quantity} of {item_name}', flush=True)
  22.         start_resp = daprClient.start_workflow(workflow_component=workflow_component,
  23.                                                workflow_name=workflow_name,
  24.                                                input=order)
  25.         _id = start_resp.instance_id
  27.         def prompt_for_approval(daprClient: DaprClient):
  28.             daprClient.raise_workflow_event(instance_id=_id, workflow_component=workflow_component, 
  29.                                             event_name="manager_approval", event_data={'approval': True})
  31.         approval_seeked = False
  32.         start_time = datetime.now()
  33.         while True:
  34.             time_delta = datetime.now() - start_time
  35.             state = daprClient.get_workflow(instance_id=_id, workflow_component=workflow_component)
  36.             if not state:
  37.                 print("Workflow not found!")  # not expected
  38.             elif state.runtime_status == "Completed" or\
  39.                     state.runtime_status == "Failed" or\
  40.                     state.runtime_status == "Terminated":
  41.                 print(f'Workflow completed! Result: {state.runtime_status}', flush=True)
  42.                 break
  43.             if time_delta.total_seconds() >= 10:
  44.                 state = daprClient.get_workflow(instance_id=_id, workflow_component=workflow_component)
  45.                 if total_cost > 50000 and (
  46.                     state.runtime_status != "Completed" or 
  47.                     state.runtime_status != "Failed" or
  48.                     state.runtime_status != "Terminated"
  49.                     ) and not approval_seeked:
  50.                     approval_seeked = True
  51.                     threading.Thread(target=prompt_for_approval(daprClient), daemon=True).start()
  53.         print("Purchase of item is ", state.runtime_status, flush=True)
  55.     def restock_inventory(self, daprClient: DaprClient, baseInventory):
  56.         for key, item in baseInventory.items():
  57.             print(f'item: {item}')
  58.             item_str = f'{{"name": "{item.item_name}", "quantity": {item.quantity},\
  59.                           "per_item_cost": {item.per_item_cost}}}'
  60.             daprClient.save_state("statestore-actors", key, item_str)
  62. if __name__ == '__main__':
  63.     app = WorkflowConsoleApp()
  64.     app.main()

order-processor/workflow.py

In workflow.py, the workflow is defined as a class with all of its associated tasks (determined by workflow activities).

  1.   def order_processing_workflow(ctx: DaprWorkflowContext, order_payload_str: OrderPayload):
  2.     """Defines the order processing workflow.
  3.     When the order is received, the inventory is checked to see if there is enough inventory to
  4.     fulfill the order. If there is enough inventory, the payment is processed and the inventory is
  5.     updated. If there is not enough inventory, the order is rejected.
  6.     If the total order is greater than $50,000, the order is sent to a manager for approval.
  7.     """
  8.     order_id = ctx.instance_id
  9.     order_payload=json.loads(order_payload_str)
  10.     yield ctx.call_activity(notify_activity, 
  11.                             input=Notification(message=('Received order ' +order_id+ ' for '
  12.                                                +f'{order_payload["quantity"]}' +' ' +f'{order_payload["item_name"]}'
  13.                                                +' at $'+f'{order_payload["total_cost"]}' +' !')))
  14.     result = yield ctx.call_activity(verify_inventory_activity,
  15.                                      input=InventoryRequest(request_id=order_id,
  16.                                                             item_name=order_payload["item_name"],
  17.                                                             quantity=order_payload["quantity"]))
  18.     if not result.success:
  19.         yield ctx.call_activity(notify_activity,
  20.                                 input=Notification(message='Insufficient inventory for '
  21.                                                    +f'{order_payload["item_name"]}'+'!'))
  22.         return OrderResult(processed=False)
  24.     if order_payload["total_cost"] > 50000:
  25.         yield ctx.call_activity(requst_approval_activity, input=order_payload)
  26.         approval_task = ctx.wait_for_external_event("manager_approval")
  27.         timeout_event = ctx.create_timer(timedelta(seconds=200))
  28.         winner = yield when_any([approval_task, timeout_event])
  29.         if winner == timeout_event:
  30.             yield ctx.call_activity(notify_activity, 
  31.                                     input=Notification(message='Payment for order '+order_id
  32.                                                        +' has been cancelled due to timeout!'))
  33.             return OrderResult(processed=False)
  34.         approval_result = yield approval_task
  35.         if approval_result["approval"]:
  36.             yield ctx.call_activity(notify_activity, input=Notification(
  37.                 message=f'Payment for order {order_id} has been approved!'))
  38.         else:
  39.             yield ctx.call_activity(notify_activity, input=Notification(
  40.                 message=f'Payment for order {order_id} has been rejected!'))
  41.             return OrderResult(processed=False)    
  43.     yield ctx.call_activity(process_payment_activity, input=PaymentRequest(
  44.         request_id=order_id, item_being_purchased=order_payload["item_name"],
  45.         amount=order_payload["total_cost"], quantity=order_payload["quantity"]))
  47.     try:
  48.         yield ctx.call_activity(update_inventory_activity, 
  49.                                 input=PaymentRequest(request_id=order_id,
  50.                                                      item_being_purchased=order_payload["item_name"],
  51.                                                      amount=order_payload["total_cost"],
  52.                                                      quantity=order_payload["quantity"]))
  53.     except Exception:
  54.         yield ctx.call_activity(notify_activity, 
  55.                                 input=Notification(message=f'Order {order_id} Failed!'))
  56.         return OrderResult(processed=False)
  58.     yield ctx.call_activity(notify_activity, input=Notification(
  59.         message=f'Order {order_id} has completed!'))
  60.     return OrderResult(processed=True)

The order-processor console app starts and manages the lifecycle of an order processing workflow that stores and retrieves data in a state store. The workflow consists of four workflow activities, or tasks:

  • NotifyActivity: Utilizes a logger to print out messages throughout the workflow
  • ReserveInventoryActivity: Checks the state store to ensure that there is enough inventory for the purchase
  • ProcessPaymentActivity: Processes and authorizes the payment
  • UpdateInventoryActivity: Removes the requested items from the state store and updates the store with the new remaining inventory value

Step 1: Pre-requisites

For this example, you will need:

Step 2: Set up the environment

Clone the sample provided in the Quickstarts repo.

  1. git clone https://github.com/dapr/quickstarts.git

In a new terminal window, navigate to the order-processor directory:

  1. cd workflows/csharp/sdk/order-processor

Step 3: Run the order processor app

In the terminal, start the order processor app alongside a Dapr sidecar:

  1. dapr run --app-id order-processor dotnet run

This starts the order-processor app with unique workflow ID and runs the workflow activities.

Expected output:

  1. == APP == Starting workflow 6d2abcc9 purchasing 10 Cars
  3. == APP == info: Microsoft.DurableTask.Client.Grpc.GrpcDurableTaskClient[40]
  4. == APP ==       Scheduling new OrderProcessingWorkflow orchestration with instance ID '6d2abcc9' and 47 bytes of input data.
  5. == APP == info: WorkflowConsoleApp.Activities.NotifyActivity[0]
  6. == APP ==       Received order 6d2abcc9 for 10 Cars at $15000
  7. == APP == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[0]
  8. == APP ==       Reserving inventory for order 6d2abcc9 of 10 Cars
  9. == APP == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[0]
  10. == APP ==       There are: 100, Cars available for purchase
  12. == APP == Your workflow has started. Here is the status of the workflow: Dapr.Workflow.WorkflowState
  14. == APP == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[0]
  15. == APP ==       Processing payment: 6d2abcc9 for 10 Cars at $15000
  16. == APP == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[0]
  17. == APP ==       Payment for request ID '6d2abcc9' processed successfully
  18. == APP == info: WorkflowConsoleApp.Activities.UpdateInventoryActivity[0]
  19. == APP ==       Checking Inventory for: Order# 6d2abcc9 for 10 Cars
  20. == APP == info: WorkflowConsoleApp.Activities.UpdateInventoryActivity[0]
  21. == APP ==       There are now: 90 Cars left in stock
  22. == APP == info: WorkflowConsoleApp.Activities.NotifyActivity[0]
  23. == APP ==       Order 6d2abcc9 has completed!
  25. == APP == Workflow Status: Completed

(Optional) Step 4: View in Zipkin

Running dapr init launches the openzipkin/zipkin Docker container. If the container has stopped running, launch the Zipkin Docker container with the following command:

  1. docker run -d -p 9411:9411 openzipkin/zipkin

View the workflow trace spans in the Zipkin web UI (typically at http://localhost:9411/zipkin/).

Workflow - 图3

What happened?

When you ran dapr run --app-id order-processor dotnet run:

  1. A unique order ID for the workflow is generated (in the above example, 6d2abcc9) and the workflow is scheduled.
  2. The NotifyActivity workflow activity sends a notification saying an order for 10 cars has been received.
  3. The ReserveInventoryActivity workflow activity checks the inventory data, determines if you can supply the ordered item, and responds with the number of cars in stock.
  4. Your workflow starts and notifies you of its status.
  5. The ProcessPaymentActivity workflow activity begins processing payment for order 6d2abcc9 and confirms if successful.
  6. The UpdateInventoryActivity workflow activity updates the inventory with the current available cars after the order has been processed.
  7. The NotifyActivity workflow activity sends a notification saying that order 6d2abcc9 has completed.
  8. The workflow terminates as completed.

order-processor/Program.cs

In the application’s program file:

  • The unique workflow order ID is generated
  • The workflow is scheduled
  • The workflow status is retrieved
  • The workflow and the workflow activities it invokes are registered
  1. using Dapr.Client;
  2. using Dapr.Workflow;
  3. //...
  5. {
  6.     services.AddDaprWorkflow(options =>
  7.     {
  8.         // Note that it's also possible to register a lambda function as the workflow
  9.         // or activity implementation instead of a class.
  10.         options.RegisterWorkflow<OrderProcessingWorkflow>();
  12.         // These are the activities that get invoked by the workflow(s).
  13.         options.RegisterActivity<NotifyActivity>();
  14.         options.RegisterActivity<ReserveInventoryActivity>();
  15.         options.RegisterActivity<ProcessPaymentActivity>();
  16.         options.RegisterActivity<UpdateInventoryActivity>();
  17.     });
  18. };
  20. //...
  22. // Generate a unique ID for the workflow
  23. string orderId = Guid.NewGuid().ToString()[..8];
  24. string itemToPurchase = "Cars";
  25. int ammountToPurchase = 10;
  27. // Construct the order
  28. OrderPayload orderInfo = new OrderPayload(itemToPurchase, 15000, ammountToPurchase);
  30. // Start the workflow
  31. Console.WriteLine("Starting workflow {0} purchasing {1} {2}", orderId, ammountToPurchase, itemToPurchase);
  33. await daprClient.StartWorkflowAsync(
  34.     workflowComponent: DaprWorkflowComponent,
  35.     workflowName: nameof(OrderProcessingWorkflow),
  36.     input: orderInfo,
  37.     instanceId: orderId);
  39. // Wait for the workflow to start and confirm the input
  40. GetWorkflowResponse state = await daprClient.WaitForWorkflowStartAsync(
  41.     instanceId: orderId,
  42.     workflowComponent: DaprWorkflowComponent);
  44. Console.WriteLine("Your workflow has started. Here is the status of the workflow: {0}", state.RuntimeStatus);
  46. // Wait for the workflow to complete
  47. state = await daprClient.WaitForWorkflowCompletionAsync(
  48.     instanceId: orderId,
  49.     workflowComponent: DaprWorkflowComponent);
  51. Console.WriteLine("Workflow Status: {0}", state.RuntimeStatus);

order-processor/Workflows/OrderProcessingWorkflow.cs

In OrderProcessingWorkflow.cs, the workflow is defined as a class with all of its associated tasks (determined by workflow activities).

  1. using Dapr.Workflow;
  2. //...
  4. class OrderProcessingWorkflow : Workflow<OrderPayload, OrderResult>
  5.     {
  6.         public override async Task<OrderResult> RunAsync(WorkflowContext context, OrderPayload order)
  7.         {
  8.             string orderId = context.InstanceId;
  10.             // Notify the user that an order has come through
  11.             await context.CallActivityAsync(
  12.                 nameof(NotifyActivity),
  13.                 new Notification($"Received order {orderId} for {order.Quantity} {order.Name} at ${order.TotalCost}"));
  15.             string requestId = context.InstanceId;
  17.             // Determine if there is enough of the item available for purchase by checking the inventory
  18.             InventoryResult result = await context.CallActivityAsync<InventoryResult>(
  19.                 nameof(ReserveInventoryActivity),
  20.                 new InventoryRequest(RequestId: orderId, order.Name, order.Quantity));
  22.             // If there is insufficient inventory, fail and let the user know 
  23.             if (!result.Success)
  24.             {
  25.                 // End the workflow here since we don't have sufficient inventory
  26.                 await context.CallActivityAsync(
  27.                     nameof(NotifyActivity),
  28.                     new Notification($"Insufficient inventory for {order.Name}"));
  29.                 return new OrderResult(Processed: false);
  30.             }
  32.             // There is enough inventory available so the user can purchase the item(s). Process their payment
  33.             await context.CallActivityAsync(
  34.                 nameof(ProcessPaymentActivity),
  35.                 new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost));
  37.             try
  38.             {
  39.                 // There is enough inventory available so the user can purchase the item(s). Process their payment
  40.                 await context.CallActivityAsync(
  41.                     nameof(UpdateInventoryActivity),
  42.                     new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost));                
  43.             }
  44.             catch (TaskFailedException)
  45.             {
  46.                 // Let them know their payment was processed
  47.                 await context.CallActivityAsync(
  48.                     nameof(NotifyActivity),
  49.                     new Notification($"Order {orderId} Failed! You are now getting a refund"));
  50.                 return new OrderResult(Processed: false);
  51.             }
  53.             // Let them know their payment was processed
  54.             await context.CallActivityAsync(
  55.                 nameof(NotifyActivity),
  56.                 new Notification($"Order {orderId} has completed!"));
  58.             // End the workflow with a success result
  59.             return new OrderResult(Processed: true);
  60.         }
  61.     }

order-processor/Activities directory

The Activities directory holds the four workflow activities used by the workflow, defined in the following files:

  • NotifyActivity.cs
  • ReserveInventoryActivity.cs
  • ProcessPaymentActivity.cs
  • UpdateInventoryActivity.cs

Watch the demo

Watch this video to walk through the Dapr Workflow .NET demo:

The order-processor console app starts and manages the lifecycle of an order processing workflow that stores and retrieves data in a state store. The workflow consists of four workflow activities, or tasks:

  • NotifyActivity: Utilizes a logger to print out messages throughout the workflow
  • RequestApprovalActivity: Requests approval for processing payment
  • ReserveInventoryActivity: Checks the state store to ensure that there is enough inventory for the purchase
  • ProcessPaymentActivity: Processes and authorizes the payment
  • UpdateInventoryActivity: Removes the requested items from the state store and updates the store with the new remaining inventory value

Step 1: Pre-requisites

For this example, you will need:

Step 2: Set up the environment

Clone the sample provided in the Quickstarts repo.

  1. git clone https://github.com/dapr/quickstarts.git

Navigate to the order-processor directory:

  1. cd workflows/java/sdk/order-processor

Install the dependencies:

  1. mvn clean install

Step 3: Run the order processor app

In the terminal, start the order processor app alongside a Dapr sidecar:

  1. dapr run --app-id WorkflowConsoleApp --resources-path ../../../components/ --dapr-grpc-port 50001 -- java -jar target/OrderProcessingService-0.0.1-SNAPSHOT.jar io.dapr.quickstarts.workflows.WorkflowConsoleApp

This starts the order-processor app with unique workflow ID and runs the workflow activities.

Expected output:

  1. == APP == *** Welcome to the Dapr Workflow console app sample!
  2. == APP == *** Using this app, you can place orders that start workflows.
  3. == APP == Start workflow runtime
  4. == APP == Sep 20, 2023 3:23:05 PM com.microsoft.durabletask.DurableTaskGrpcWorker startAndBlock
  5. == APP == INFO: Durable Task worker is connecting to sidecar at 127.0.0.1:50001.
  7. == APP == ==========Begin the purchase of item:==========
  8. == APP == Starting order workflow, purchasing 10 of cars
  10. == APP == scheduled new workflow instance of OrderProcessingWorkflow with instance ID: edceba90-9c45-4be8-ad40-60d16e060797
  11. == APP == [Thread-0] INFO io.dapr.workflows.WorkflowContext - Starting Workflow: io.dapr.quickstarts.workflows.OrderProcessingWorkflow
  12. == APP == [Thread-0] INFO io.dapr.workflows.WorkflowContext - Instance ID(order ID): edceba90-9c45-4be8-ad40-60d16e060797
  13. == APP == [Thread-0] INFO io.dapr.workflows.WorkflowContext - Current Orchestration Time: 2023-09-20T19:23:09.755Z
  14. == APP == [Thread-0] INFO io.dapr.workflows.WorkflowContext - Received Order: OrderPayload [itemName=cars, totalCost=150000, quantity=10]
  15. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.NotifyActivity - Received Order: OrderPayload [itemName=cars, totalCost=150000, quantity=10]
  16. == APP == workflow instance edceba90-9c45-4be8-ad40-60d16e060797 started
  17. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.ReserveInventoryActivity - Reserving inventory for order 'edceba90-9c45-4be8-ad40-60d16e060797' of 10 cars
  18. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.ReserveInventoryActivity - There are 100 cars available for purchase
  19. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.ReserveInventoryActivity - Reserved inventory for order 'edceba90-9c45-4be8-ad40-60d16e060797' of 10 cars
  20. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.RequestApprovalActivity - Requesting approval for order: OrderPayload [itemName=cars, totalCost=150000, quantity=10]
  21. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.RequestApprovalActivity - Approved requesting approval for order: OrderPayload [itemName=cars, totalCost=150000, quantity=10]
  22. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.ProcessPaymentActivity - Processing payment: edceba90-9c45-4be8-ad40-60d16e060797 for 10 cars at $150000
  23. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.ProcessPaymentActivity - Payment for request ID 'edceba90-9c45-4be8-ad40-60d16e060797' processed successfully
  24. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.UpdateInventoryActivity - Updating inventory for order 'edceba90-9c45-4be8-ad40-60d16e060797' of 10 cars
  25. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.UpdateInventoryActivity - Updated inventory for order 'edceba90-9c45-4be8-ad40-60d16e060797': there are now 90 cars left in stock
  26. == APP == [Thread-0] INFO io.dapr.quickstarts.workflows.activities.NotifyActivity - Order completed! : edceba90-9c45-4be8-ad40-60d16e060797
  28. == APP == workflow instance edceba90-9c45-4be8-ad40-60d16e060797 completed, out is: {"processed":true}

(Optional) Step 4: View in Zipkin

Running dapr init launches the openzipkin/zipkin Docker container. If the container has stopped running, launch the Zipkin Docker container with the following command:

  1. docker run -d -p 9411:9411 openzipkin/zipkin

View the workflow trace spans in the Zipkin web UI (typically at http://localhost:9411/zipkin/).

Workflow - 图4

What happened?

When you ran dapr run:

  1. A unique order ID for the workflow is generated (in the above example, edceba90-9c45-4be8-ad40-60d16e060797) and the workflow is scheduled.
  2. The NotifyActivity workflow activity sends a notification saying an order for 10 cars has been received.
  3. The ReserveInventoryActivity workflow activity checks the inventory data, determines if you can supply the ordered item, and responds with the number of cars in stock.
  4. Once approved, your workflow starts and notifies you of its status.
  5. The ProcessPaymentActivity workflow activity begins processing payment for order edceba90-9c45-4be8-ad40-60d16e060797 and confirms if successful.
  6. The UpdateInventoryActivity workflow activity updates the inventory with the current available cars after the order has been processed.
  7. The NotifyActivity workflow activity sends a notification saying that order edceba90-9c45-4be8-ad40-60d16e060797 has completed.
  8. The workflow terminates as completed.

order-processor/WorkflowConsoleApp.java

In the application’s program file:

  • The unique workflow order ID is generated
  • The workflow is scheduled
  • The workflow status is retrieved
  • The workflow and the workflow activities it invokes are registered
  1. package io.dapr.quickstarts.workflows;
  2. import io.dapr.client.DaprClient;
  3. import io.dapr.client.DaprClientBuilder;
  4. import io.dapr.workflows.client.DaprWorkflowClient;
  6. public class WorkflowConsoleApp {
  8.   private static final String STATE_STORE_NAME = "statestore-actors";
  10.   // ...
  11.   public static void main(String[] args) throws Exception {
  12.     System.out.println("*** Welcome to the Dapr Workflow console app sample!");
  13.     System.out.println("*** Using this app, you can place orders that start workflows.");
  14.     // Wait for the sidecar to become available
  15.     Thread.sleep(5 * 1000);
  17.     // Register the OrderProcessingWorkflow and its activities with the builder.
  18.     WorkflowRuntimeBuilder builder = new WorkflowRuntimeBuilder().registerWorkflow(OrderProcessingWorkflow.class);
  19.     builder.registerActivity(NotifyActivity.class);
  20.     builder.registerActivity(ProcessPaymentActivity.class);
  21.     builder.registerActivity(RequestApprovalActivity.class);
  22.     builder.registerActivity(ReserveInventoryActivity.class);
  23.     builder.registerActivity(UpdateInventoryActivity.class);
  25.     // Build the workflow runtime
  26.     try (WorkflowRuntime runtime = builder.build()) {
  27.       System.out.println("Start workflow runtime");
  28.       runtime.start(false);
  29.     }
  31.     InventoryItem inventory = prepareInventoryAndOrder();
  33.     DaprWorkflowClient workflowClient = new DaprWorkflowClient();
  34.     try (workflowClient) {
  35.       executeWorkflow(workflowClient, inventory);
  36.     }
  38.   }
  40.   // Start the workflow runtime, pulling and executing tasks
  41.   private static void executeWorkflow(DaprWorkflowClient workflowClient, InventoryItem inventory) {
  42.     System.out.println("==========Begin the purchase of item:==========");
  43.     String itemName = inventory.getName();
  44.     int orderQuantity = inventory.getQuantity();
  45.     int totalcost = orderQuantity * inventory.getPerItemCost();
  46.     OrderPayload order = new OrderPayload();
  47.     order.setItemName(itemName);
  48.     order.setQuantity(orderQuantity);
  49.     order.setTotalCost(totalcost);
  50.     System.out.println("Starting order workflow, purchasing " + orderQuantity + " of " + itemName);
  52.     String instanceId = workflowClient.scheduleNewWorkflow(OrderProcessingWorkflow.class, order);
  53.     System.out.printf("scheduled new workflow instance of OrderProcessingWorkflow with instance ID: %s%n",
  54.         instanceId);
  56.     // Check workflow instance start status
  57.     try {
  58.       workflowClient.waitForInstanceStart(instanceId, Duration.ofSeconds(10), false);
  59.       System.out.printf("workflow instance %s started%n", instanceId);
  60.     } catch (TimeoutException e) {
  61.       System.out.printf("workflow instance %s did not start within 10 seconds%n", instanceId);
  62.       return;
  63.     }
  65.     // Check workflow instance complete status
  66.     try {
  67.       WorkflowInstanceStatus workflowStatus = workflowClient.waitForInstanceCompletion(instanceId,
  68.           Duration.ofSeconds(30),
  69.           true);
  70.       if (workflowStatus != null) {
  71.         System.out.printf("workflow instance %s completed, out is: %s %n", instanceId,
  72.             workflowStatus.getSerializedOutput());
  73.       } else {
  74.         System.out.printf("workflow instance %s not found%n", instanceId);
  75.       }
  76.     } catch (TimeoutException e) {
  77.       System.out.printf("workflow instance %s did not complete within 30 seconds%n", instanceId);
  78.     }
  80.   }
  82.   private static InventoryItem prepareInventoryAndOrder() {
  83.     // prepare 100 cars in inventory
  84.     InventoryItem inventory = new InventoryItem();
  85.     inventory.setName("cars");
  86.     inventory.setPerItemCost(15000);
  87.     inventory.setQuantity(100);
  88.     DaprClient daprClient = new DaprClientBuilder().build();
  89.     restockInventory(daprClient, inventory);
  91.     // prepare order for 10 cars
  92.     InventoryItem order = new InventoryItem();
  93.     order.setName("cars");
  94.     order.setPerItemCost(15000);
  95.     order.setQuantity(10);
  96.     return order;
  97.   }
  99.   private static void restockInventory(DaprClient daprClient, InventoryItem inventory) {
  100.     String key = inventory.getName();
  101.     daprClient.saveState(STATE_STORE_NAME, key, inventory).block();
  102.   }
  103. }

OrderProcessingWorkflow.java

In OrderProcessingWorkflow.java, the workflow is defined as a class with all of its associated tasks (determined by workflow activities).

  1. package io.dapr.quickstarts.workflows;
  2. import io.dapr.workflows.Workflow;
  4. public class OrderProcessingWorkflow extends Workflow {
  6.   @Override
  7.   public WorkflowStub create() {
  8.     return ctx -> {
  9.       Logger logger = ctx.getLogger();
  10.       String orderId = ctx.getInstanceId();
  11.       logger.info("Starting Workflow: " + ctx.getName());
  12.       logger.info("Instance ID(order ID): " + orderId);
  13.       logger.info("Current Orchestration Time: " + ctx.getCurrentInstant());
  15.       OrderPayload order = ctx.getInput(OrderPayload.class);
  16.       logger.info("Received Order: " + order.toString());
  17.       OrderResult orderResult = new OrderResult();
  18.       orderResult.setProcessed(false);
  20.       // Notify the user that an order has come through
  21.       Notification notification = new Notification();
  22.       notification.setMessage("Received Order: " + order.toString());
  23.       ctx.callActivity(NotifyActivity.class.getName(), notification).await();
  25.       // Determine if there is enough of the item available for purchase by checking
  26.       // the inventory
  27.       InventoryRequest inventoryRequest = new InventoryRequest();
  28.       inventoryRequest.setRequestId(orderId);
  29.       inventoryRequest.setItemName(order.getItemName());
  30.       inventoryRequest.setQuantity(order.getQuantity());
  31.       InventoryResult inventoryResult = ctx.callActivity(ReserveInventoryActivity.class.getName(),
  32.           inventoryRequest, InventoryResult.class).await();
  34.       // If there is insufficient inventory, fail and let the user know
  35.       if (!inventoryResult.isSuccess()) {
  36.         notification.setMessage("Insufficient inventory for order : " + order.getItemName());
  37.         ctx.callActivity(NotifyActivity.class.getName(), notification).await();
  38.         ctx.complete(orderResult);
  39.         return;
  40.       }
  42.       // Require orders over a certain threshold to be approved
  43.       if (order.getTotalCost() > 5000) {
  44.         ApprovalResult approvalResult = ctx.callActivity(RequestApprovalActivity.class.getName(),
  45.             order, ApprovalResult.class).await();
  46.         if (approvalResult != ApprovalResult.Approved) {
  47.           notification.setMessage("Order " + order.getItemName() + " was not approved.");
  48.           ctx.callActivity(NotifyActivity.class.getName(), notification).await();
  49.           ctx.complete(orderResult);
  50.           return;
  51.         }
  52.       }
  54.       // There is enough inventory available so the user can purchase the item(s).
  55.       // Process their payment
  56.       PaymentRequest paymentRequest = new PaymentRequest();
  57.       paymentRequest.setRequestId(orderId);
  58.       paymentRequest.setItemBeingPurchased(order.getItemName());
  59.       paymentRequest.setQuantity(order.getQuantity());
  60.       paymentRequest.setAmount(order.getTotalCost());
  61.       boolean isOK = ctx.callActivity(ProcessPaymentActivity.class.getName(),
  62.           paymentRequest, boolean.class).await();
  63.       if (!isOK) {
  64.         notification.setMessage("Payment failed for order : " + orderId);
  65.         ctx.callActivity(NotifyActivity.class.getName(), notification).await();
  66.         ctx.complete(orderResult);
  67.         return;
  68.       }
  70.       inventoryResult = ctx.callActivity(UpdateInventoryActivity.class.getName(),
  71.           inventoryRequest, InventoryResult.class).await();
  72.       if (!inventoryResult.isSuccess()) {
  73.         // If there is an error updating the inventory, refund the user
  74.         // paymentRequest.setAmount(-1 * paymentRequest.getAmount());
  75.         // ctx.callActivity(ProcessPaymentActivity.class.getName(),
  76.         // paymentRequest).await();
  78.         // Let users know their payment processing failed
  79.         notification.setMessage("Order failed to update inventory! : " + orderId);
  80.         ctx.callActivity(NotifyActivity.class.getName(), notification).await();
  81.         ctx.complete(orderResult);
  82.         return;
  83.       }
  85.       // Let user know their order was processed
  86.       notification.setMessage("Order completed! : " + orderId);
  87.       ctx.callActivity(NotifyActivity.class.getName(), notification).await();
  89.       // Complete the workflow with order result is processed
  90.       orderResult.setProcessed(true);
  91.       ctx.complete(orderResult);
  92.     };
  93.   }
  95. }

activities directory

The Activities directory holds the four workflow activities used by the workflow, defined in the following files:

Tell us what you think!

We’re continuously working to improve our Quickstart examples and value your feedback. Did you find this Quickstart helpful? Do you have suggestions for improvement?

Join the discussion in our discord channel.

Next steps

Explore Dapr tutorials >>

Last modified October 12, 2023: Update config.toml (#3826) (0ffc2e7)