public async Task <OrchestrationQueryResult> GetOrchestrationsAsync(OrchestrationQuery query, CancellationToken cancellationToken = default)
{
var request = new GetOrchestrationsRequest
{
Top = query.Top,
ContinuationToken = query.ContinuationToken,
InstanceId = query.InstanceId,
Name = query.Name,
CreatedTimeFrom = ToTimestamp(query.CreatedTimeFrom),
CreatedTimeTo = ToTimestamp(query.CreatedTimeTo)
};
if (query.RuntimeStatus != null)
{
request.RuntimeStatus.AddRange(query.RuntimeStatus.Select(s => (int)s));
}
var callOptions = new CallOptions(cancellationToken: cancellationToken);
var response = await _client.GetOrchestrationsAsync(request, callOptions);
return(new OrchestrationQueryResult
{
Orchestrations = response.States
.Select(s => _options.DataConverter.Deserialize <OrchestrationState>(s))
.ToArray(),
Count = response.Count,
ContinuationToken = response.ContinuationToken
});
}
public async Task <OrchestrationQueryResult> GetOrchestrationsAsync(
OrchestrationQuery query,
CancellationToken cancellationToken = default)
{
var queryCondition = new OrchestrationInstanceStatusQueryCondition
{
InstanceIdPrefix = query.InstanceId,
CreatedTimeFrom = query.CreatedTimeFrom ?? default,
CreatedTimeTo = query.CreatedTimeTo ?? default,
RuntimeStatus = query.RuntimeStatus
};
var azureQueryResult = await _azureStorageOrchestrationService.GetOrchestrationStateAsync(queryCondition, query.Top, query.ContinuationToken);
var queryResult = new OrchestrationQueryResult
{
Orchestrations = azureQueryResult.OrchestrationState.ToArray(),
ContinuationToken = azureQueryResult.ContinuationToken,
};
return(queryResult);
}
public override async Task <GetOrchestrationsResponse> GetOrchestrations(GetOrchestrationsRequest request, ServerCallContext context)
{
var query = new OrchestrationQuery
{
Top = request.Top,
ContinuationToken = request.ContinuationToken,
InstanceId = request.InstanceId,
Name = request.Name,
CreatedTimeFrom = request.CreatedTimeFrom?.ToDateTime(),
CreatedTimeTo = request.CreatedTimeTo?.ToDateTime(),
RuntimeStatus = request.RuntimeStatus.Select(s => (OrchestrationStatus)s).ToArray()
};
var queryResult = await _extendedOrchestrationServiceClient.GetOrchestrationsAsync(query, context.CancellationToken);
var response = new GetOrchestrationsResponse
{
States = { queryResult.Orchestrations.Select(s => _options.DataConverter.Serialize(s)) },
Count = queryResult.Count,
ContinuationToken = queryResult.ContinuationToken
};
return(response);
}
public override async Task <OrchestrationQueryResult> GetOrchestrationWithQueryAsync(OrchestrationQuery query, CancellationToken cancellationToken)
{
if (query.TaskHubNames?.Any() == true)
{
throw new NotSupportedException("Querying orchestrations by task hub name is not supported.");
}
var sqlOrchestrationQuery = new SqlOrchestrationQuery
{
CreatedTimeFrom = query.CreatedTimeFrom.GetValueOrDefault(),
CreatedTimeTo = query.CreatedTimeTo.GetValueOrDefault(),
FetchInput = query.FetchInputsAndOutputs,
FetchOutput = query.FetchInputsAndOutputs,
InstanceIdPrefix = query.InstanceIdPrefix,
PageSize = query.PageSize
};
if (query.RuntimeStatus?.Any() == true)
{
sqlOrchestrationQuery.StatusFilter = new HashSet <OrchestrationStatus>(query.RuntimeStatus);
}
// The continuation token is just a page number.
if (string.IsNullOrWhiteSpace(query.ContinuationToken))
{
sqlOrchestrationQuery.PageNumber = 0;
}
else if (int.TryParse(query.ContinuationToken, out int pageNumber))
{
sqlOrchestrationQuery.PageNumber = pageNumber;
}
else
{
throw new ArgumentException($"The continuation token '{query.ContinuationToken}' is invalid.", nameof(query));
}
IReadOnlyCollection <OrchestrationState> results = await this.GetManyOrchestrationsAsync(sqlOrchestrationQuery, cancellationToken);
string?continuationToken =
results.Count == sqlOrchestrationQuery.PageSize ? (sqlOrchestrationQuery.PageNumber + 1).ToString() : null;
return(new OrchestrationQueryResult(results, continuationToken));
}
public abstract Task <OrchestrationQueryResult> GetOrchestrationWithQueryAsync(
OrchestrationQuery query,
CancellationToken cancellationToken);
public async Task <OrchestrationQueryResult> GetOrchestrationsAsync(OrchestrationQuery query, CancellationToken cancellationToken = default)
{
using (var dbContext = _dbContextFactory())
{
var queryable = dbContext.Executions as IQueryable <Entities.Execution>;
if (!string.IsNullOrEmpty(query.InstanceId))
{
queryable = queryable.Where(i => i.InstanceId.StartsWith(query.InstanceId));
}
if (!string.IsNullOrEmpty(query.Name))
{
queryable = queryable.Where(i => i.Name.StartsWith(query.Name));
}
if (query.CreatedTimeFrom != null)
{
queryable = queryable.Where(i => i.CreatedTime >= query.CreatedTimeFrom);
}
if (query.CreatedTimeTo != null)
{
queryable = queryable.Where(i => i.CreatedTime <= query.CreatedTimeTo);
}
if (query.RuntimeStatus != null && query.RuntimeStatus.Any())
{
queryable = queryable.Where(i => query.RuntimeStatus.Contains(i.Status));
}
long index;
long count;
var continuationToken = EFCoreContinuationToken.Parse(query.ContinuationToken);
if (continuationToken != null)
{
index = continuationToken.Index;
count = continuationToken.Count;
queryable = queryable.Where(i =>
i.CreatedTime < continuationToken.CreatedTime ||
i.CreatedTime == continuationToken.CreatedTime && continuationToken.InstanceId.CompareTo(i.InstanceId) < 0);
}
else
{
index = 0;
count = await queryable.LongCountAsync();
}
var instances = await queryable
.OrderByDescending(x => x.CreatedTime)
.ThenByDescending(x => x.InstanceId)
.Take(query.Top)
.ToArrayAsync();
var mappedInstances = instances
.Select(_executionMapper.MapToState)
.ToArray();
return(new OrchestrationQueryResult
{
Orchestrations = mappedInstances,
Count = count,
ContinuationToken = count > index + instances.Length && instances.Length > 0
? new EFCoreContinuationToken
{
Index = index + instances.Length,
Count = count,
CreatedTime = instances.Last().CreatedTime,
InstanceId = instances.Last().InstanceId,
}.Serialize()
: null
});
}
}
