#36 refactor for new Storage Queue client SDK

Author: DanielLarsenNZ

dotnet/ServerlessMicroservices.Shared/ServerlessMicroservices.Shared.csproj

@@ -5,6 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Azure.Storage.Queues" Version="12.8.0" />
     <PackageReference Include="Dapper" Version="1.50.5" />
     <PackageReference Include="IdentityModel" Version="3.9.0" />
     <PackageReference Include="Microsoft.ApplicationInsights" Version="2.19.0" />

dotnet/ServerlessMicroservices.Shared/Services/StorageService.cs

@@ -1,5 +1,5 @@
-using Microsoft.WindowsAzure.Storage;
-using Microsoft.WindowsAzure.Storage.Queue;
+using Azure.Core;
+using Azure.Storage.Queues;
 using Newtonsoft.Json;
 using ServerlessMicroservices.Models;
 using System;
@@ -16,10 +16,10 @@ public class StorageService : IStorageService
         private ISettingService _settingService;
         private ILoggerService _loggerService;
 
-        private CloudQueue _tripManagersQueue;
-        private CloudQueue _tripMonitorsQueue;
-        private CloudQueue _tripDemosQueue;
-        private CloudQueue _tripDriversQueue;
+        private QueueClient _tripManagersQueue;
+        private QueueClient _tripMonitorsQueue;
+        private QueueClient _tripDemosQueue;
+        private QueueClient _tripDriversQueue;
 
         public StorageService(ISettingService setting, ILoggerService logger)
         {
@@ -33,8 +33,7 @@ public async Task Enqueue(TripItem trip)
 
             if (_tripManagersQueue != null)
             {
-                var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(trip));
-                await _tripManagersQueue.AddMessageAsync(queueMessage);
+                await _tripManagersQueue.SendMessageAsync(JsonConvert.SerializeObject(trip)); 
             }
         }
 
@@ -44,8 +43,7 @@ public async Task Enqueue(TripDemoState tripDemoState)
 
             if (_tripDemosQueue != null)
             {
-                var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(tripDemoState));
-                await _tripDemosQueue.AddMessageAsync(queueMessage);
+                await _tripDemosQueue.SendMessageAsync(JsonConvert.SerializeObject(tripDemoState));
             }
         }
 
@@ -55,66 +53,66 @@ public async Task Enqueue(string tripCode, string driverCode)
 
             if (_tripDriversQueue != null)
             {
-                var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(new TripDriver
+                await _tripDriversQueue.SendMessageAsync(JsonConvert.SerializeObject(JsonConvert.SerializeObject(new TripDriver
                 {
                     TripCode = tripCode,
                     DriverCode = driverCode
-                }));
-                await _tripDriversQueue.AddMessageAsync(queueMessage);
+                })));
             }
         }
 
         // PRIVATE//
 
         private async Task InitializeStorage()
         {
+            //TODO: #45 Not thread safe
             if (_isStorageInitialized)
                 return;
 
             var error = "";
 
             try
             {
+
+                //TODO: #45 Swallowing errors
                 if (!string.IsNullOrEmpty(_settingService.GetStorageAccount()))
                 {
                     // Queues Initialization
-                    var queueStorageAccount = CloudStorageAccount.Parse(_settingService.GetStorageAccount());
-                    // Get context object for working with queues, and set a default retry policy appropriate for a web user interface.
-                    var queueClient = queueStorageAccount.CreateCloudQueueClient();
-                    //queueClient.DefaultRequestOptions.RetryPolicy = new LinearRetry(TimeSpan.FromSeconds(3), 3);
+
+                    // Retry policy appropriate for a web user interface.
+                    var queueClientOptions = new QueueClientOptions();
+                    queueClientOptions.Retry.Mode = RetryMode.Fixed;
+                    queueClientOptions.Retry.Delay = TimeSpan.FromSeconds(3);
+                    queueClientOptions.Retry.MaxRetries = 3;
+
 
                     var tripManagersQueueName = _settingService.GetTripManagersQueueName();
                     if (!string.IsNullOrEmpty(tripManagersQueueName))
-                    {
-                        _tripManagersQueue = queueClient.GetQueueReference(tripManagersQueueName);
-                        await _tripManagersQueue.CreateIfNotExistsAsync();
-                    }
+                        _tripManagersQueue = await InitializeQueueClient(tripManagersQueueName, queueClientOptions);
                     else
+                        //TODO: #45 Swallowing errors
                         _loggerService.Log("tripManagersQueueName is empty");
 
                     var tripMonitorsQueueName = _settingService.GetTripMonitorsQueueName();
                     if (!string.IsNullOrEmpty(tripMonitorsQueueName))
                     {
-                        _tripMonitorsQueue = queueClient.GetQueueReference(tripMonitorsQueueName);
-                        await _tripMonitorsQueue.CreateIfNotExistsAsync();
+                        _tripMonitorsQueue = await InitializeQueueClient(tripMonitorsQueueName, queueClientOptions);
                     }
                     else
                         _loggerService.Log("tripMonitorsQueueName is empty");
 
                     var tripDemosQueueName = _settingService.GetTripDemosQueueName();
                     if (!string.IsNullOrEmpty(tripDemosQueueName))
                     {
-                        _tripDemosQueue = queueClient.GetQueueReference(tripDemosQueueName);
-                        await _tripDemosQueue.CreateIfNotExistsAsync();
+                        _tripDemosQueue = await InitializeQueueClient(tripDemosQueueName, queueClientOptions);
                     }
                     else
                         _loggerService.Log("tripDemosQueueName is empty");
 
                     var tripDriversQueueName = _settingService.GetTripDriversQueueName();
                     if (!string.IsNullOrEmpty(tripDriversQueueName))
                     {
-                        _tripDriversQueue = queueClient.GetQueueReference(tripDriversQueueName);
-                        await _tripDriversQueue.CreateIfNotExistsAsync();
+                        _tripDriversQueue = await InitializeQueueClient(tripDriversQueueName, queueClientOptions);
                     }
                     else
                         _loggerService.Log("tripDriversQueueName is empty");
@@ -132,5 +130,12 @@ private async Task InitializeStorage()
                 _loggerService.Log($"{LOG_TAG} - InitializeStorage - Error: {error}");
             }
         }
+
+        private async Task<QueueClient> InitializeQueueClient(string queueName, QueueClientOptions options)
+        {
+            var queueClient = new QueueClient(_settingService.GetStorageAccount(), queueName, options);
+            await queueClient.CreateIfNotExistsAsync();
+            return queueClient;
+        }
     }
 }