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())
});
}
