State Management in Azure Service Fabric

private long LongRandom() {
    byte[] buf = new byte[8];
    rnd.NextBytes(buf);
    long longRand = BitConverter.ToInt64(buf, 0);
    return longRand;
}

Now, let's implement the checkout service. We've already done it before with other services, but I'll speed through it again. First of all, I'll delete the RunAsync method since we simply don't need it, remove the unnecessary comments, and as you remember, in order to expose an endpoint, we need to replace CreateServiceReplicaListener with this identical code we've written before. Of course, in order for that to work, you need to either reference the Microsoft.ServiceFabric.Services.Remoting Library.

protected override IEnumerable<ServiceReplicaListener> CreateServiceReplicaListener() {
    return new[]{
        new ServiceReplicaListener(context => new FabricTransportServiceRemotingListener(context, this))
    };
}

Step 11. Derive the CheckoutService Class from the ICheckoutService. Of course, Visual Studio doesn't know about it, so we need to add a reference to the model project.

And now let's simply implement this interface. We've got two methods, Checkout and GetOrderHistory, which are not implemented yet. Let's implement them and explain how it works.

First, we will create the CheckoutSummary class instance which holds the results of the checkout, sets the date, and initializes the product with an empty collection. Before we check out, we need to get the user basket. Therefore, we must get a reference to the IUserActor.

To get the user actor, I wrote a helper method, GetUserActor, which simply creates an actor proxy, calling the UserActor service. Then we need the IProductCatalog service. This is contained within ECommerce.Product catalog.Model Project and again, I was able to write a trivial helper method for this. It simply creates a service proxy for the product catalog service.

Now that we have both user basket and catalog service, what we would like to do in order to proceed to the checkout is to enumerate through the basket. For each basket line, get a product from the basket, create the CheckoutProduct entity, and fill in all the required fields (i.e. product, price, quantity, calculate the total price, clear the basket, and add this purchase to the history). To add the product to the history, I wrote another helper method. All it does is create an instance of a reliable collection called history, open a transaction, and add the CheckoutSummary to that history. That will help us later retrieve the user's purchasing history through the same API.

Step 12. Implement the CheckoutAsync method as follows.

public async Task<CheckoutSummary> CheckoutAsync(string userId)
{
    var result = new CheckoutSummary();
    result.Date = DateTime.UtcNow;
    result.Products = new List<CheckoutProduct>();
    IUserActor userActor = GetUserActor(userId);
    BasketItem[] basket = await userActor.GetBasket();
    IProductCatalogService catalogService = GetProductCatalogService();
    foreach (BasketItem basketLine in basket)
    {
        Product product = await catalogService.GetProductAsync(basketLine.ProductId);
        var checkoutProduct = new CheckoutProduct
        {
            Product = product,
            Price = product.Price,
            Quantity = basketLine.Quantity
        };
        result.Products.Add(checkoutProduct);
    }
    result.TotalPrice = result.Products.Sum(p => p.Price);
    await userActor.ClearBasket();
    await AddToHistoryAsync(result);
    return result;
}

Step 13. Add the following helper methods.

private IUserActor GetUserActor(string userId)
{
    return ActorProxy.Create<IUserActor>(new ActorId(userId), new Uri("fabric:/Ecommerce/UserActorService"));
}

private IProductCatalogService GetProductCatalogService()
{
    var proxyFactory = new ServiceProxyFactory(c => new FabricTransportServiceRemotingClientFactory());
    return proxyFactory.CreateServiceProxy<IProductCatalogService>(new Uri("fabric:/Ecommerce/Ecommerce.ProductCatalog"), new ServicePartitionKey(0));
}

private async Task AddToHistoryAsync(CheckoutSummary checkout) {
    IReliableDictionary<DateTime, CheckoutSummary> history = await StateManager.GetOrAddAsync<IReliableDictionary<DateTime, CheckoutSummary>>("history");
    using (ITransaction tx = StateManager.CreateTransaction()) {
        await history.AddAsync(tx, checkout.Date, checkout);
        await tx.CommitAsync();
    }
}

Now, implementing order history is easy considering we've already written the history item for the history collection. Of course, this method has to be async. We get the reference to the history collection, create a transaction, simply enumerate through all of the items in the history collection, and return it as a list of checkout summaries.

Step 14. Implement GetOrderHistoryAsync as follows.

public async Task<CheckoutSummary[]> GetOrderHistoryAsync(string userId)
{
    var result = new List<CheckoutSummary>();
    IReliableDictionary<DateTime, CheckoutSummary> history = await StateManager.GetOrAddAsync<IReliableDictionary<DateTime, CheckoutSummary>>("history");
    using (ITransaction tx = StateManager.CreateTransaction())
    {
        IAsyncEnumerable<KeyValuePair<DateTime, CheckoutSummary>> allProducts = await history.CreateEnumerableAsync(tx, EnumerableMode.Unordered);
        using (IAsyncEnumerator<KeyValuePair<DateTime, CheckoutSummary>> enumerator = allProducts.GetAsyncEnumerator())
        {
            while (await enumerator.MoveNextAsync(CancellationToken.None))
            {
                KeyValuePair<DateTime, CheckoutSummary> current = enumerator.Current;
                result.Add(current.Value);
            }
        }
    }
    return result.ToArray();
}

Test Using Postman

We can test it by launching our application, and again using this wonderful Postman tool. We'll start by calling the product's API to get the product list from the product catalog.

Let's add a product to the user's basket by calling the Post method.

Now, we perform a checkout for user 1. And as you can see, we have the checkout summary. Additionally, we still have the price, date, and list of products. All seems to be correct, so this is done. That’s how we manage the state in service fabric.

Applicable Cases

• Avoid complex systems involving dependencies and coordinating shared state
• When you want to avoid using explicit locks to protect the shared state
• Classic synchronization problems like the dining philosopher's and the sleeping barber's problem
• Highly available services
• Scalable services

Summary

In this article, we learned about managing state in Azure Service Fabric.