public void PurgeOrchestrationHistoryTest() { taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration), typeof(InstanceStoreTestOrchestration2)) .AddTaskActivities(new Activity1()) .Start(); for (int i = 0; i < 25; i++) { string instanceId = "apiservice" + i; client.CreateOrchestrationInstance( i % 2 == 0 ? typeof(InstanceStoreTestOrchestration) : typeof(InstanceStoreTestOrchestration2), instanceId, "DONTTHROW"); } Thread.Sleep(TimeSpan.FromSeconds(30)); var query = new OrchestrationStateQuery(); IEnumerable <OrchestrationState> states = client.QueryOrchestrationStates(query); Assert.AreEqual(25, states.Count()); client.PurgeOrchestrationInstanceHistoryAsync (DateTime.UtcNow, OrchestrationStateTimeRangeFilterType.OrchestrationCreatedTimeFilter).Wait(); states = client.QueryOrchestrationStates(query); Assert.AreEqual(0, states.Count()); for (int i = 0; i < 10; i++) { string instanceId = "apiservice" + i; client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), instanceId, "DONTTHROW"); } Thread.Sleep(TimeSpan.FromSeconds(10)); DateTime cutoff = DateTime.UtcNow.Subtract(TimeSpan.FromSeconds(5)); for (int i = 10; i < 20; i++) { string instanceId = "apiservice" + i; client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), instanceId, "DONTTHROW"); } Thread.Sleep(TimeSpan.FromSeconds(30)); states = client.QueryOrchestrationStates(query); Assert.AreEqual(20, states.Count()); client.PurgeOrchestrationInstanceHistoryAsync (cutoff, OrchestrationStateTimeRangeFilterType.OrchestrationCreatedTimeFilter).Wait(); states = client.QueryOrchestrationStates(query); Assert.AreEqual(10, states.Count()); foreach (OrchestrationState s in states) { Assert.IsTrue(s.CreatedTime > cutoff); } }
public Task <IEnumerable <AzureTableOrchestrationStateEntity> > QueryOrchestrationStatesAsync( OrchestrationStateQuery stateQuery) { TableQuery <AzureTableOrchestrationStateEntity> query = CreateQueryInternal(stateQuery, -JumpStartTableScanIntervalInDays, false); return(ReadAllEntitiesAsync(query, this.historyTable)); }
public async Task QueryByTimeForRunningOrchestrationsTest() { await this.taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .StartAsync(); var instanceId1 = "first"; DateTime firstBatchStart = DateTime.UtcNow; OrchestrationInstance id1 = await this.client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), instanceId1, "WAIT_DONTTHROW"); await TestHelpers.WaitForInstanceAsync(this.client, id1, 60, false); // running orchestrations never get reported in any CompletedTimeFilter query OrchestrationStateQuery query = new OrchestrationStateQuery().AddTimeRangeFilter(firstBatchStart, firstBatchStart.AddSeconds(60), OrchestrationStateTimeRangeFilterType.OrchestrationCompletedTimeFilter); IEnumerable <OrchestrationState> response = await this.queryClient.QueryOrchestrationStatesAsync(query); Assert.AreEqual(0, response.Count()); await TestHelpers.WaitForInstanceAsync(this.client, id1, 60); // now we should get a result response = await this.queryClient.QueryOrchestrationStatesAsync(query); Assert.AreEqual(1, response.Count()); }
public async Task PurgeManyOrchestrationHistoryTest() { await this.taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration), typeof(InstanceStoreTestOrchestration2)) .AddTaskActivities(new Activity1()) .StartAsync(); for (var i = 0; i < 110; i++) { string instanceId = "apiservice" + i; await this.client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), instanceId, "DONTTHROW"); } Thread.Sleep(TimeSpan.FromSeconds(50)); var query = new OrchestrationStateQuery(); IEnumerable <OrchestrationState> states = await this.queryClient.QueryOrchestrationStatesAsync(query); Assert.AreEqual(110, states.Count()); await this.client.PurgeOrchestrationInstanceHistoryAsync (DateTime.UtcNow, OrchestrationStateTimeRangeFilterType.OrchestrationCreatedTimeFilter); states = await this.queryClient.QueryOrchestrationStatesAsync(query); Assert.AreEqual(0, states.Count()); }
public Task <TableQuerySegment <AzureTableOrchestrationStateEntity> > QueryOrchestrationStatesSegmentedAsync( OrchestrationStateQuery stateQuery, TableContinuationToken continuationToken, int count) { TableQuery <AzureTableOrchestrationStateEntity> query = CreateQueryInternal(stateQuery, count, false); return(historyTable.ExecuteQuerySegmentedAsync(query, continuationToken)); }
public Task <IEnumerable <OrchestrationStateEntity> > QueryOrchestrationStatesAsync( OrchestrationStateQuery stateQuery) { TableQuery <OrchestrationStateEntity> query = CreateQueryInternal(stateQuery, -1); return(ReadAllEntitiesAsync(query)); }
public async Task <IEnumerable <OrchestrationStateInstanceEntity> > GetOrchestrationStateAsync(string instanceId, bool allInstances) { var query = new OrchestrationStateQuery().AddInstanceFilter(instanceId); var stateEntities = (await Client.QueryOrchestrationStatesAsync(query))?.Results; IEnumerable <OrchestrationStateInstanceEntity> jumpStartEntities = (await Client.QueryJumpStartOrchestrationsAsync(query)).Results?.Select(s => tableStateToStateEvent(s)); IEnumerable <OrchestrationState> states = stateEntities.Select(stateEntity => stateEntity); IEnumerable <OrchestrationState> jumpStartStates = jumpStartEntities.Select(j => j.State) .Where(js => !states.Any(s => s.OrchestrationInstance.InstanceId == js.OrchestrationInstance.InstanceId)); var newStates = states.Concat(jumpStartStates); if (allInstances) { return(newStates.Select(tableStateToStateEvent));; } foreach (OrchestrationState state in newStates) { // TODO: This will just return the first non-ContinuedAsNew orchestration and not the latest one. if (state.OrchestrationStatus != OrchestrationStatus.ContinuedAsNew) { return(new List <OrchestrationStateInstanceEntity>() { tableStateToStateEvent(state) }); } } return(null); }
public async Task QueryMultiGenerationalTest() { await this.taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .StartAsync(); var instance1 = "apiservice1_upgrade1"; OrchestrationInstance id1 = await this.client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), instance1, "WAIT_NEWGEN"); await TestHelpers.WaitForInstanceAsync(this.client, id1, 60); // completed apiService1 --> 1 result OrchestrationStateQuery query = new OrchestrationStateQuery(). AddInstanceFilter("apiservice1", true). AddStatusFilter(OrchestrationStatus.Completed); IList <OrchestrationState> response = (await this.queryClient.QueryOrchestrationStatesAsync(query)).ToList(); Assert.IsTrue(response.Count == 1); Assert.AreEqual(id1.InstanceId, response.First().OrchestrationInstance.InstanceId); // continuedAsNew apiService1 --> 2 results query = new OrchestrationStateQuery(). AddInstanceFilter("apiservice1", true). AddStatusFilter(OrchestrationStatus.ContinuedAsNew); response = (await this.queryClient.QueryOrchestrationStatesAsync(query)).ToList(); Assert.IsTrue(response.Count == 2); }
public void QueryMultiGenerationalTest() { taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .Start(); string instance1 = "apiservice1_upgrade1"; OrchestrationInstance id1 = client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), instance1, "WAIT_NEWGEN"); TestHelpers.WaitForInstance(client, id1, 60); // completed apiservice1 --> 1 result OrchestrationStateQuery query = new OrchestrationStateQuery(). AddInstanceFilter("apiservice1", true). AddStatusFilter(OrchestrationStatus.Completed); IEnumerable <OrchestrationState> response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 1); Assert.AreEqual(id1.InstanceId, response.First().OrchestrationInstance.InstanceId); // continuedasnew apiservice1 --> 2 results query = new OrchestrationStateQuery(). AddInstanceFilter("apiservice1", true). AddStatusFilter(OrchestrationStatus.ContinuedAsNew); response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 2); }
public Task <TableQuerySegment <AzureTableOrchestrationStateEntity> > QueryJumpStartOrchestrationsSegmentedAsync( OrchestrationStateQuery stateQuery, TableContinuationToken continuationToken, int count) { TableQuery <AzureTableOrchestrationStateEntity> query = CreateQueryInternal(stateQuery, count, true); return(this.jumpStartTable.ExecuteQuerySegmentedAsync(query, continuationToken)); }
public void QueryByLastUpdatedTimeTest() { taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .Start(); string instanceId1 = "first"; DateTime firstBatchStart = DateTime.UtcNow; OrchestrationInstance id1 = client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), instanceId1, "WAIT_AND_WAIT_DONTTHROW"); TestHelpers.WaitForInstance(client, id1, 60, false); // running orchestrations never get reported in any CompletedTimeFilter query OrchestrationStateQuery query = new OrchestrationStateQuery().AddTimeRangeFilter(firstBatchStart, firstBatchStart.AddSeconds(5), OrchestrationStateTimeRangeFilterType.OrchestrationLastUpdatedTimeFilter); IEnumerable <OrchestrationState> response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 1); TestHelpers.WaitForInstance(client, id1, 60); response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 0); query = new OrchestrationStateQuery().AddTimeRangeFilter(firstBatchStart.AddSeconds(15), DateTime.MaxValue, OrchestrationStateTimeRangeFilterType.OrchestrationLastUpdatedTimeFilter); // now we should get a result response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 1); }
public void CreateQueryWithoutFilter() { var tableClient = new AzureTableClient("myHub", ConnectionString); var stateQuery = new OrchestrationStateQuery(); TableQuery <AzureTableOrchestrationStateEntity> query = tableClient.CreateQueryInternal(stateQuery, 1, false); Assert.AreEqual("(PartitionKey eq 'IS')", query.FilterString); }
public async Task QueryByNameVersionTest() { ObjectCreator <TaskOrchestration> c1 = new NameValueObjectCreator <TaskOrchestration>( "orch1", "1.0", typeof(InstanceStoreTestOrchestration)); ObjectCreator <TaskOrchestration> c2 = new NameValueObjectCreator <TaskOrchestration>( "orch1", "2.0", typeof(InstanceStoreTestOrchestration)); ObjectCreator <TaskOrchestration> c3 = new NameValueObjectCreator <TaskOrchestration>( "orch2", string.Empty, typeof(InstanceStoreTestOrchestration)); await taskHub.AddTaskOrchestrations(c1, c2, c3) .AddTaskActivities(new Activity1()) .StartAsync(); OrchestrationInstance id1 = await client.CreateOrchestrationInstanceAsync("orch1", "1.0", "DONTTHROW"); OrchestrationInstance id2 = await client.CreateOrchestrationInstanceAsync("orch1", "2.0", "DONTTHROW"); OrchestrationInstance id3 = await client.CreateOrchestrationInstanceAsync("orch2", string.Empty, "DONTTHROW"); await TestHelpers.WaitForInstanceAsync(client, id1, 60); await TestHelpers.WaitForInstanceAsync(client, id2, 60); await TestHelpers.WaitForInstanceAsync(client, id3, 60); OrchestrationStateQuery query = new OrchestrationStateQuery().AddNameVersionFilter("orch1"); IEnumerable <OrchestrationState> response = await queryClient.QueryOrchestrationStatesAsync(query); Assert.IsTrue(response.Count() == 2); // TODO : for some reason sometimes the order gets inverted //Assert.AreEqual(id1.InstanceId, response.First().OrchestrationInstance.InstanceId); //Assert.AreEqual(id2.InstanceId, response.ElementAt(1).OrchestrationInstance.InstanceId); query = new OrchestrationStateQuery().AddNameVersionFilter("orch1", "2.0"); response = await queryClient.QueryOrchestrationStatesAsync(query); Assert.AreEqual(1, response.Count()); Assert.AreEqual(id2.InstanceId, response.First().OrchestrationInstance.InstanceId); query = new OrchestrationStateQuery().AddNameVersionFilter("orch1", string.Empty); response = await queryClient.QueryOrchestrationStatesAsync(query); Assert.IsTrue(response.Count() == 0); query = new OrchestrationStateQuery().AddNameVersionFilter("orch2", string.Empty); response = await queryClient.QueryOrchestrationStatesAsync(query); Assert.IsTrue(response.Count() == 1); Assert.AreEqual(id3.InstanceId, response.First().OrchestrationInstance.InstanceId); }
public void QueryByTimeTest() { taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .Start(); string instanceId1 = "first"; string instanceId2 = "second"; string instanceId3 = "third"; DateTime firstBatchStart = DateTime.UtcNow; OrchestrationInstance id1 = client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), instanceId1, "WAIT_DONTTHROW"); TestHelpers.WaitForInstance(client, id1, 60); DateTime firstBatchEnd = DateTime.UtcNow; DateTime secondBatchStart = DateTime.UtcNow; OrchestrationInstance id2 = client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), instanceId2, "WAIT_DONTTHROW"); OrchestrationInstance id3 = client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), instanceId3, "WAIT_DONTTHROW"); TestHelpers.WaitForInstance(client, id2, 60); TestHelpers.WaitForInstance(client, id3, 60); DateTime secondBatchEnd = DateTime.UtcNow; // timespan during which only first batch was created OrchestrationStateQuery query = new OrchestrationStateQuery().AddTimeRangeFilter(firstBatchStart, firstBatchStart.AddSeconds(5), OrchestrationStateTimeRangeFilterType.OrchestrationCreatedTimeFilter); IEnumerable <OrchestrationState> response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 1); Assert.AreEqual(instanceId1, response.First().OrchestrationInstance.InstanceId); // timespan during which first batch finished query = new OrchestrationStateQuery().AddTimeRangeFilter(firstBatchEnd.Subtract(TimeSpan.FromSeconds(5)), firstBatchEnd.AddSeconds(5), OrchestrationStateTimeRangeFilterType.OrchestrationCompletedTimeFilter); response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 1); Assert.AreEqual(instanceId1, response.First().OrchestrationInstance.InstanceId); // timespan during which second batch was created query = new OrchestrationStateQuery().AddTimeRangeFilter(firstBatchEnd.Subtract(TimeSpan.FromSeconds(5)), firstBatchEnd.AddSeconds(5), OrchestrationStateTimeRangeFilterType.OrchestrationCreatedTimeFilter); response = client.QueryOrchestrationStates(query); Assert.IsTrue(response.Count() == 2); Assert.AreEqual(instanceId2, response.First().OrchestrationInstance.InstanceId); Assert.AreEqual(instanceId3, response.ElementAt(1).OrchestrationInstance.InstanceId); }
public static void DumpAllInstances(TaskHubClient client, int hours) { DateTime currentTime = DateTime.UtcNow; OrchestrationStateQuery statusQuery = new OrchestrationStateQuery(); statusQuery .AddTimeRangeFilter(currentTime.Subtract(TimeSpan.FromHours(hours)), currentTime, OrchestrationStateTimeRangeFilterType.OrchestrationCreatedTimeFilter); DumpInstances(client.QueryOrchestrationStates(statusQuery)); }
private void startQuery(OrchestrationStateQuery query) { ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => { while (true) { Thread.Sleep(5000); } })); }
public static IEnumerable <OrchestrationState> GetInstancesByState(this SqlInstanceStore instanceStore, OrchestrationStatus status) { List <OrchestrationState> instances = new List <OrchestrationState>(); var byNameQuery = new OrchestrationStateQuery(); byNameQuery.AddStatusFilter(status); return(instanceStore.QueryOrchestrationStatesAsync(byNameQuery).Result); }
public async Task QueryWithMultipleFiltersTest() { await taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .StartAsync(); string instance1 = "apiservice1_upgrade1"; string instance2 = "apiservice1_upgrade2"; string instance3 = "system_gc"; OrchestrationInstance id1 = await client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), instance1, "WAIT_THROW"); OrchestrationInstance id2 = await client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), instance2, "WAIT_DONTTHROW"); OrchestrationInstance id3 = await client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), instance3, "WAIT_DONTTHROW"); await TestHelpers.WaitForInstanceAsync(client, id1, 60); await TestHelpers.WaitForInstanceAsync(client, id2, 60); await TestHelpers.WaitForInstanceAsync(client, id3, 60); // completed apiservice1 --> 1 result OrchestrationStateQuery query = new OrchestrationStateQuery(). AddInstanceFilter("apiservice1", true). AddStatusFilter(OrchestrationStatus.Completed); IEnumerable <OrchestrationState> response = await queryClient.QueryOrchestrationStatesAsync(query); Assert.IsTrue(response.Count() == 1); Assert.AreEqual(id2.InstanceId, response.First().OrchestrationInstance.InstanceId); // failed apiservice1 -> 1 result query = new OrchestrationStateQuery(). AddInstanceFilter("apiservice1", true). AddStatusFilter(OrchestrationStatus.Failed); response = await queryClient.QueryOrchestrationStatesAsync(query); Assert.IsTrue(response.Count() == 1); Assert.AreEqual(id1.InstanceId, response.First().OrchestrationInstance.InstanceId); // failed gc -> 0 results query = new OrchestrationStateQuery(). AddInstanceFilter("system", true). AddStatusFilter(OrchestrationStatus.Failed); response = await queryClient.QueryOrchestrationStatesAsync(query); Assert.IsTrue(response.Count() == 0); }
public void CreateQueryWithPrimaryFilter() { var tableClient = new AzureTableClient("myHub", ConnectionString); var stateQuery = new OrchestrationStateQuery(); stateQuery.AddInstanceFilter("myInstance"); TableQuery <AzureTableOrchestrationStateEntity> query = tableClient.CreateQueryInternal(stateQuery, 1, false); Assert.AreEqual("(PartitionKey eq 'IS') and (RowKey ge 'ID_EID_myInstance') and (RowKey lt 'ID_EID_myInstancf')", query.FilterString); }
public async Task QueryByStatusTest() { await taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .StartAsync(); OrchestrationInstance id1 = await client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), "WAIT_THROW"); OrchestrationInstance id2 = await client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), "WAIT_DONTTHROW"); OrchestrationStateQuery completedQuery = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Completed); OrchestrationStateQuery runningQuery = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Running); OrchestrationStateQuery pendingQuery = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Pending); OrchestrationStateQuery failedQuery = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Failed); await TestHelpers.WaitForInstanceAsync(client, id1, 60, false); await TestHelpers.WaitForInstanceAsync(client, id2, 60, false); IEnumerable <OrchestrationState> pendingStates = await queryClient.QueryOrchestrationStatesAsync(pendingQuery); IEnumerable <OrchestrationState> completedStates = await queryClient.QueryOrchestrationStatesAsync(completedQuery); IEnumerable <OrchestrationState> failedStates = await queryClient.QueryOrchestrationStatesAsync(failedQuery); Assert.AreEqual(2, pendingStates.Count()); Assert.AreEqual(0, completedStates.Count()); Assert.AreEqual(0, failedStates.Count()); await TestHelpers.WaitForInstanceAsync(client, id1, 60); await TestHelpers.WaitForInstanceAsync(client, id2, 60); IEnumerable <OrchestrationState> runningStates = await queryClient.QueryOrchestrationStatesAsync(runningQuery); completedStates = await queryClient.QueryOrchestrationStatesAsync(completedQuery); failedStates = await queryClient.QueryOrchestrationStatesAsync(failedQuery); Assert.AreEqual(0, runningStates.Count()); Assert.AreEqual(1, completedStates.Count()); Assert.AreEqual(1, failedStates.Count()); Assert.AreEqual(id1.InstanceId, failedStates.First().OrchestrationInstance.InstanceId); Assert.AreEqual(id2.InstanceId, completedStates.First().OrchestrationInstance.InstanceId); }
/// <summary> /// Gets the numer of running instances. /// </summary> /// <param name="microservice"></param> /// <returns>Gets the numer of running instances of the service.</returns> public int GetNumOfRunningInstances(Microservice microservice) { var byNameQuery = new OrchestrationStateQuery(); byNameQuery.AddStatusFilter(OrchestrationStatus.Running); byNameQuery.AddNameVersionFilter(microservice.Orchestration.FullName); var result = m_HubClient.QueryOrchestrationStates(byNameQuery); var cnt = result.Count(svc => svc.OrchestrationStatus == OrchestrationStatus.Running); return(cnt); }
private IEnumerable <OrchestrationState> loadStates(string orchestrationFullName, bool runningOnly = true) { var byNameQuery = new OrchestrationStateQuery(); byNameQuery.AddNameVersionFilter(orchestrationFullName); if (runningOnly) { byNameQuery.AddStatusFilter(OrchestrationStatus.Running); } var oStates = m_HubClient.QueryOrchestrationStates(byNameQuery); return(oStates); }
/// <summary> /// Get a list of orchestration states from the instance storage table which match the specified /// orchestration state query. /// </summary> /// <param name="stateQuery">Orchestration state query to execute</param> /// <returns></returns> public async Task <IEnumerable <OrchestrationState> > QueryOrchestrationStatesAsync( OrchestrationStateQuery stateQuery) { IEnumerable <AzureTableOrchestrationStateEntity> result = await tableClient.QueryOrchestrationStatesAsync(stateQuery).ConfigureAwait(false); // Query from JumpStart table IEnumerable <AzureTableOrchestrationStateEntity> jumpStartEntities = await this.tableClient.QueryJumpStartOrchestrationsAsync(stateQuery).ConfigureAwait(false); IEnumerable <AzureTableOrchestrationStateEntity> newStates = result.Concat(jumpStartEntities .Where(js => !result.Any(s => s.State.OrchestrationInstance.InstanceId == js.State.OrchestrationInstance.InstanceId))); return(newStates.Select(stateEntity => stateEntity.State)); }
public static List <OrchestrationState> GetRunningInstances(this SqlInstanceStore instanceStore) { List <OrchestrationState> instances = new List <OrchestrationState>(); var byNameQuery = new OrchestrationStateQuery(); byNameQuery.AddStatusFilter(OrchestrationStatus.Running); instances.AddRange(GetInstancesByState(instanceStore, OrchestrationStatus.Running)); // instances.AddRange(GetInstancesByState(instanceStore, OrchestrationStatus.ContinuedAsNew)); instances.AddRange(GetInstancesByState(instanceStore, OrchestrationStatus.Pending)); return(instances); }
/// <summary> /// Gets the number of running instances. /// </summary> /// <param name="microservice"></param> /// <returns>Gets the number of running instances of the service. /// If m_StorageConnectionString is not confiogured this method returns 0.</returns> public int GetNumOfRunningInstances(Microservice microservice) { if (String.IsNullOrEmpty(this.m_StorageConnectionString)) { return(0); } var byNameQuery = new OrchestrationStateQuery(); byNameQuery.AddStatusFilter(OrchestrationStatus.Running); byNameQuery.AddNameVersionFilter(microservice.Orchestration.FullName); var result = m_HubClient.QueryOrchestrationStates(byNameQuery); return(result.Count()); }
/// <summary> /// Get a list of orchestration states from the instance storage table which match the specified /// orchestration state query. /// </summary> /// <param name="stateQuery">Orchestration state query to execute</param> /// <returns></returns> public async Task <IEnumerable <OrchestrationState> > QueryOrchestrationStatesAsync( OrchestrationStateQuery stateQuery) { var result = await Client.QueryOrchestrationStatesAsync(stateQuery).ConfigureAwait(false); var states = result.Results.Select(s => tableStateToStateEvent(s)); // Query from JumpStart table var jumpStartEntities = await this.Client.QueryJumpStartOrchestrationsAsync(stateQuery).ConfigureAwait(false); var jumpStartResult = result.Results.Select(s => tableStateToStateEvent(s)); var newStates = states.Concat(jumpStartResult.Where(js => !states.Any(s => s.State.OrchestrationInstance.InstanceId == js.State.OrchestrationInstance.InstanceId))); return(newStates.Select(stateEntity => stateEntity.State)); }
internal TableQuery <AzureTableOrchestrationStateEntity> CreateQueryInternal(OrchestrationStateQuery stateQuery, int count, bool useTimeRangePrimaryFilter) { OrchestrationStateQueryFilter primaryFilter = null; IEnumerable <OrchestrationStateQueryFilter> secondaryFilters = null; Tuple <OrchestrationStateQueryFilter, IEnumerable <OrchestrationStateQueryFilter> > filters = stateQuery.GetFilters(); if (filters != null) { primaryFilter = filters.Item1; secondaryFilters = filters.Item2; } string filterExpression = GetPrimaryFilterExpression(primaryFilter, useTimeRangePrimaryFilter); if (string.IsNullOrWhiteSpace(filterExpression)) { throw new InvalidOperationException("Invalid primary filter"); } if (secondaryFilters != null) { filterExpression = secondaryFilters.Aggregate(filterExpression, (current, filter) => { string newFilter = current; string secondaryFilter = GetSecondaryFilterExpression(filter); if (!string.IsNullOrWhiteSpace(secondaryFilter)) { newFilter += " and " + secondaryFilter; } return(newFilter); }); } TableQuery <AzureTableOrchestrationStateEntity> query = new TableQuery <AzureTableOrchestrationStateEntity>().Where(filterExpression); if (count != -1) { query.TakeCount = count; } return(query); }
public void QueryDuplicateFiltersTest() { OrchestrationStateQuery query = new OrchestrationStateQuery().AddInstanceFilter(null, false); AssertException <ArgumentException>(() => query.AddInstanceFilter(null, false)); query = new OrchestrationStateQuery().AddNameVersionFilter(null, null); AssertException <ArgumentException>(() => query.AddNameVersionFilter(null, null)); query = new OrchestrationStateQuery().AddTimeRangeFilter(DateTime.MaxValue, DateTime.MaxValue, OrchestrationStateTimeRangeFilterType.OrchestrationLastUpdatedTimeFilter); AssertException <ArgumentException>(() => query.AddTimeRangeFilter(DateTime.MaxValue, DateTime.MaxValue, OrchestrationStateTimeRangeFilterType.OrchestrationLastUpdatedTimeFilter)); query = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Completed); AssertException <ArgumentException>(() => query.AddStatusFilter(OrchestrationStatus.Completed)); }
public void QueryByStatusTest() { taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .Start(); OrchestrationInstance id1 = client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), "WAIT_THROW"); OrchestrationInstance id2 = client.CreateOrchestrationInstance(typeof(InstanceStoreTestOrchestration), "WAIT_DONTTHROW"); OrchestrationStateQuery completedQuery = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Completed); OrchestrationStateQuery runningQuery = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Running); OrchestrationStateQuery failedQuery = new OrchestrationStateQuery().AddStatusFilter(OrchestrationStatus.Failed); TestHelpers.WaitForInstance(client, id1, 60, false); TestHelpers.WaitForInstance(client, id2, 60, false); IEnumerable <OrchestrationState> runningStates = client.QueryOrchestrationStates(runningQuery); IEnumerable <OrchestrationState> completedStates = client.QueryOrchestrationStates(completedQuery); IEnumerable <OrchestrationState> failedStates = client.QueryOrchestrationStates(failedQuery); Assert.IsTrue(runningStates.Count() == 2); Assert.IsTrue(completedStates.Count() == 0); Assert.IsTrue(failedStates.Count() == 0); TestHelpers.WaitForInstance(client, id1, 60); TestHelpers.WaitForInstance(client, id2, 60); runningStates = client.QueryOrchestrationStates(runningQuery); completedStates = client.QueryOrchestrationStates(completedQuery); failedStates = client.QueryOrchestrationStates(failedQuery); Assert.IsTrue(runningStates.Count() == 0); Assert.IsTrue(completedStates.Count() == 1); Assert.IsTrue(failedStates.Count() == 1); Assert.AreEqual(id1.InstanceId, failedStates.First().OrchestrationInstance.InstanceId); Assert.AreEqual(id2.InstanceId, completedStates.First().OrchestrationInstance.InstanceId); }
/// <summary> /// Gets a list of orchestration states for a given instance /// </summary> /// <param name="instanceId">The instance id to return state for</param> /// <param name="allInstances">Flag indicating whether to get all history execution ids or just the most recent</param> /// <returns>List of matching orchestration states</returns> public async Task <IEnumerable <OrchestrationStateInstanceEntity> > GetOrchestrationStateAsync(string instanceId, bool allInstances) { OrchestrationStateQuery query = new OrchestrationStateQuery().AddInstanceFilter(instanceId); query = allInstances ? query : query.AddStatusFilter(OrchestrationStatus.ContinuedAsNew, FilterComparisonType.NotEquals); // Fetch unscheduled orchestrations from JumpStart table // We need to get this first to avoid a race condition. IEnumerable <AzureTableOrchestrationStateEntity> jumpStartEntities = await Utils.ExecuteWithRetries(() => this.tableClient.QueryJumpStartOrchestrationsAsync(query), string.Empty, "GetOrchestrationStateAsync-jumpStartEntities", MaxRetriesTableStore, IntervalBetweenRetriesSecs).ConfigureAwait(false); IEnumerable <AzureTableOrchestrationStateEntity> stateEntities = await Utils.ExecuteWithRetries(() => this.tableClient.QueryOrchestrationStatesAsync(query), string.Empty, "GetOrchestrationStateAsync-stateEntities", MaxRetriesTableStore, IntervalBetweenRetriesSecs).ConfigureAwait(false); IEnumerable <OrchestrationState> states = stateEntities.Select(stateEntity => stateEntity.State); IEnumerable <OrchestrationState> jumpStartStates = jumpStartEntities.Select(j => j.State) .Where(js => states.All(s => s.OrchestrationInstance.InstanceId != js.OrchestrationInstance.InstanceId)); IEnumerable <OrchestrationState> newStates = states.Concat(jumpStartStates); if (allInstances) { return(newStates.Select(TableStateToStateEvent)); } // ReSharper disable once PossibleMultipleEnumeration if (!newStates.Any()) { return(new OrchestrationStateInstanceEntity[0]); } // ReSharper disable once PossibleMultipleEnumeration return(new List <OrchestrationStateInstanceEntity> { TableStateToStateEvent(newStates.OrderByDescending(x => x.LastUpdatedTime).FirstOrDefault()) }); }