Chaining Pattern - Part 2 - Azure Durable Functions | Tech Playground

If you need to define a workflow that executes tasks in sequence, the Chaining Pattern is the application pattern to use with Durable Functions.

This is a series where I am explaining the components of durable functions¹ and the different application patterns of implementation.

Check the PlayGoKids repository for this article demo.

Understanding the Flow

The Chaining pattern allows for the execution of activities in sequence, and in-between, states are saved. In this example we have an Order example, where different steps are executed in sequence: Initialize Order, Validate Order, Process Order and Save Order.

The Order is created as the activities are executed.

Starter Function (aka DurableClient)

The starter receives an Order as input:

1
2
3
4
5
6
7
8
9
public class Order
{
    public int OrderId { get; set; }
    public string OrderNumber { get; set; }
    public string ProductSKu { get; set; }
    public int Quantity { get; set; }
    public DateTime OrderDate { get; set; }
    public string OrderStatus { get; set; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
[FunctionName($"{nameof(Chaining)}_HttpStart")]
public async Task<HttpResponseMessage> HttpStart(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
    [DurableClient] IDurableOrchestrationClient starter,
    ILogger log)
{
    var order = await req.Content.ReadAsAsync<Order>();

    var instanceId = await starter.StartNewAsync(nameof(Orchestrator), order);

    log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

    return starter.CreateCheckStatusResponse(req, instanceId);
}

This is an HTTPTrigger function that receives the Order input, which initially receives a ProductSku and Quantity as available in this CURL request:

1
2
3
4
5
6
curl --location --request GET 'http://localhost:7071/Chaining_HttpStart' \
--header 'Content-Type: application/json' \
--data-raw '{
    "ProductSku": "Milk",
    "Quantity": 1
}'

Orchestrator Function

The Orchestrator contains the calls to all Order activities. It receives an Order as input and returns the outputs (different Order properties). Check the PlayGoKids repository for details of IOrderService.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
[FunctionName(nameof(Orchestrator))]
public async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var input = context.GetInput<Order>(); // sku and quantity

    var outputs = new List<string>
    {
        await context.CallActivityAsync<string>(nameof(IOrderService.InitializeOrder), input),
        await context.CallActivityAsync<string>(nameof(IOrderService.ValidateOrder), input),
        await context.CallActivityAsync<string>(nameof(IOrderService.ProcessOrder), input),
        await context.CallActivityAsync<string>(nameof(IOrderService.SaveOrder), input),
    };

    return outputs;
}

Activity Functions

The activities were created in order Top-down, displayed below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Activity
{
    private readonly IOrderService _orderService;

    public Activity(IOrderService orderService)
    {
        _orderService = orderService;
    }

    [FunctionName(nameof(IOrderService.InitializeOrder))]
    public string Initialize([ActivityTrigger] Order order, ILogger log)
    {
        log.LogInformation($"Initializing order.");
        var initializedOrder = _orderService.InitializeOrder(order);
        return initializedOrder.OrderNumber;
    }

    [FunctionName(nameof(IOrderService.ValidateOrder))]
    public string ValidateOrder([ActivityTrigger] Order order, ILogger log)
    {
        log.LogInformation($"Validating order.");
        var validatedOrder = _orderService.ValidateOrder(order);
        return validatedOrder.Quantity.ToString();
    }

    [FunctionName(nameof(IOrderService.ProcessOrder))]
    public string ProcessOrder([ActivityTrigger] Order order, ILogger log)
    {
        log.LogInformation($"Processing order.");
        var processedOrder = _orderService.ProcessOrder(order);
        return processedOrder.OrderDate.ToString("o");
    }

    [FunctionName(nameof(IOrderService.SaveOrder))]
    public string SaveOrder([ActivityTrigger] Order order, ILogger log)
    {
        log.LogInformation($"Saving order.");
        var savedOrder = _orderService.SaveOrder(order);
        return savedOrder.OrderId.ToString();
    }
}

The OrderService is just a dummy that implements the Activity actions:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class OrderService : IOrderService
{
    public Order InitializeOrder(Order order)
    {
        order.OrderNumber = $"ON-RANDOM"; // generate number
        order.OrderStatus = nameof(InitializeOrder);
        return order;
    }

    public Order ValidateOrder(Order order)
    {
        if (order.Quantity == 0) // validate quantity
        {
            order.Quantity = 1; // at least one item
        }

        order.OrderStatus = nameof(ValidateOrder);
        return order;
    }

    public Order ProcessOrder(Order order)
    {
        order.OrderDate = DateTime.Now; // generate date
        order.OrderStatus = nameof(ProcessOrder);
        return order;
    }

    public Order SaveOrder(Order order)
    {
        order.OrderId = 1000; // generate id
        order.OrderStatus = nameof(SaveOrder);
        return order;
    }
}

This is an example of how to use the Chaining pattern, applied to the creation of Orders.

In the next article of the series let’s check out how to use the Fan out/fan in pattern.

Full Series
Major components
Function chaining
Fan out/fan in
Async HTTP APIs
Monitor
Human interaction
Aggregator (stateful entities)

Azure Durable Functions link ↩︎

Comments & Discussion

Join the conversation! Share your thoughts and connect with other readers.

Understanding the Flow

Starter Function (aka DurableClient)

Orchestrator Function

Activity Functions

Share this article:

Comments & Discussion