DurableTask.AzureStorage API to enumerate instances

src/DurableTask.AzureStorage/Tracking/AzureTableTrackingStore.cs

@@ -305,6 +305,86 @@ public override async Task<OrchestrationState> GetStateAsync(string instanceId,
             return orchestrationState;
         }
 
+        /// <inheritdoc />
+        public override async Task<IList<OrchestrationState>> GetStateAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var query = new TableQuery();
+            TableContinuationToken token = null;
+            var instanceTableEntities = new List<DynamicTableEntity>(100);
+            var stopwatch = new Stopwatch();
+            var requestCount = 0;
+            bool finishedEarly = false;
+
+            while (true)
+            {
+                requestCount++;
+                stopwatch.Start();
+                var segment = await this.instancesTable.ExecuteQuerySegmentedAsync(query, token); // TODO make sure if it has enough parameters
+                stopwatch.Stop();
+
+                int previousCount = instanceTableEntities.Count;
+                instanceTableEntities.AddRange(segment);
+
+                // TODO do we need these?
+                this.stats.StorageRequests.Increment();
+                this.stats.TableEntitiesRead.Increment(instanceTableEntities.Count - previousCount);
+
+                token = segment.ContinuationToken;
+                if (finishedEarly || token == null || cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }      
+            }
+
+            IList<OrchestrationState> orchestrationStates;
+
+            orchestrationStates = new List<OrchestrationState>(instanceTableEntities.Count);
+
+            if (instanceTableEntities.Count > 0)
+            {
+                foreach(DynamicTableEntity entity in instanceTableEntities)
+                {
+                    var instance = new OrchestrationInstance();
+                    instance.InstanceId = entity.Properties["PartitionKey"].ToString();
+
+                    // TODO we need to discuss the parameter and query structure.
+                    orchestrationStates.Add(
+                        new OrchestrationState
+                        {
+                            CompletedTime = DateTime.Parse(entity.Properties["CompletedTime"]?.ToString()),
+                            Name = entity.Properties["Name"]?.ToString(),
+                            OrchestrationInstance = instance,
+                            OrchestrationStatus = ConvertStatus(entity.Properties["OrchestrationStatus"].ToString())
+                        }
+                    );
+                }
+            }
+            return orchestrationStates;
+        }
+
+        private OrchestrationStatus ConvertStatus(string state)
+        {
+            switch(state)
+            {
+                case "Canceled":
+                    return OrchestrationStatus.Canceled;
+                case "Completed":
+                    return OrchestrationStatus.Completed;
+                case "ContinuedAsNew":
+                    return OrchestrationStatus.ContinuedAsNew;
+                case "Failed":
+                    return OrchestrationStatus.Failed;
+                case "Pending":
+                    return OrchestrationStatus.Pending;
+                case "Running":
+                    return OrchestrationStatus.Running;
+                case "Terminated":
+                    return OrchestrationStatus.Terminated;
+                default:
+                    throw new ArgumentException($"OrchestrationStatus is not what I expected: {state}");
+            }
+        }
+
         /// <inheritdoc />
         public override Task PurgeHistoryAsync(DateTime thresholdDateTimeUtc, OrchestrationStateTimeRangeFilterType timeRangeFilterType)
         {

src/DurableTask.AzureStorage/Tracking/ITrackingStore.cs

@@ -75,6 +75,12 @@ interface ITrackingStore
         /// <param name="executionId">Execution Id</param>
         Task<OrchestrationState> GetStateAsync(string instanceId, string executionId);
 
+        /// <summary>
+        /// Get The Orchestration State for querying all orchestration instances
+        /// </summary>
+        /// <returns></returns>
+        Task<IList<OrchestrationState>> GetStateAsync(CancellationToken cancellationToken = default(CancellationToken));
+
         /// <summary>
         /// Used to set a state in the tracking store whenever a new execution is initiated from the client
         /// </summary>

src/DurableTask.AzureStorage/Tracking/InstanceStoreBackedTrackingStore.cs

@@ -95,6 +95,12 @@ public override async Task<OrchestrationState> GetStateAsync(string instanceId,
             }
         }
 
+        /// <inheritdoc />
+        public override Task<IList<OrchestrationState>> GetStateAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            throw new NotImplementedException();
+        }
+
         /// <inheritdoc />
         public override Task PurgeHistoryAsync(DateTime thresholdDateTimeUtc, OrchestrationStateTimeRangeFilterType timeRangeFilterType)
         {

src/DurableTask.AzureStorage/Tracking/TrackingStoreBase.cs

@@ -42,6 +42,9 @@ abstract class TrackingStoreBase : ITrackingStore
         /// <inheritdoc />
         public abstract Task<OrchestrationState> GetStateAsync(string instanceId, string executionId);
 
+        /// <inheritdoc />
+        public abstract Task<IList<OrchestrationState>> GetStateAsync(CancellationToken cancellationToken = default(CancellationToken));
+
         /// <inheritdoc />
         public abstract Task PurgeHistoryAsync(DateTime thresholdDateTimeUtc, OrchestrationStateTimeRangeFilterType timeRangeFilterType);