public async Task <OrchestrationState> WaitForOrchestrationAsync(
string instanceId,
string executionId,
TimeSpan timeout,
CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(instanceId))
{
throw new ArgumentException(nameof(instanceId));
}
var stoppableCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(
cancellationToken, _stopCts.Token).Token;
var state = await BackoffPollingHelper.PollAsync(async() =>
{
return(await GetOrchestrationStateAsync(instanceId, executionId));
},
s => IsFinalExecutionStatus(s.OrchestrationStatus),
timeout,
_options.PollingInterval,
stoppableCancellationToken);
if (!IsFinalExecutionStatus(state.OrchestrationStatus))
{
return(null);
}
return(state);
}
public TaskHubQueue(
CloudQueue storageQueue,
AzureStorageOrchestrationServiceSettings settings,
AzureStorageOrchestrationServiceStats stats,
MessageManager messageManager)
{
this.storageQueue = storageQueue;
this.storageAccountName = storageQueue.ServiceClient.Credentials.AccountName;
this.settings = settings;
this.stats = stats;
this.messageManager = messageManager;
TimeSpan minPollingDelay = TimeSpan.FromMilliseconds(50);
TimeSpan maxPollingDelay = AzureStorageOrchestrationService.MaxQueuePollingDelay;
this.backoffHelper = new BackoffPollingHelper(minPollingDelay, maxPollingDelay);
}
public async Task <IList <TaskMessage> > FetchNewOrchestrationMessagesAsync(
TaskOrchestrationWorkItem workItem)
{
return(await BackoffPollingHelper.PollAsync(async() =>
{
using (var dbContext = _dbContextFactory())
{
var messages = await FetchNewMessagesAsync(dbContext);
await dbContext.SaveChangesAsync();
return messages;
}
},
x => x.Count > 0,
_options.FetchNewMessagesPollingTimeout,
_options.PollingInterval,
_stopCancellationToken));
}
public TaskHubQueue(
AzureStorageClient azureStorageClient,
string queueName,
MessageManager messageManager)
{
this.azureStorageClient = azureStorageClient;
this.messageManager = messageManager;
this.storageAccountName = azureStorageClient.QueueAccountName;
this.settings = azureStorageClient.Settings;
this.storageQueue = this.azureStorageClient.GetQueueReference(queueName);
TimeSpan minPollingDelay = TimeSpan.FromMilliseconds(50);
TimeSpan maxPollingDelay = this.settings.MaxQueuePollingInterval;
if (maxPollingDelay < minPollingDelay)
{
maxPollingDelay = minPollingDelay;
}
this.backoffHelper = new BackoffPollingHelper(minPollingDelay, maxPollingDelay);
}
public async Task <TaskOrchestrationWorkItem> LockNextTaskOrchestrationWorkItemAsync(
TimeSpan receiveTimeout,
INameVersionInfo[] orchestrations,
CancellationToken cancellationToken)
{
var stoppableCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(
cancellationToken, _stopCts.Token).Token;
return(await BackoffPollingHelper.PollAsync(async() =>
{
using (var dbContext = _dbContextFactory())
{
var instance = await LockNextInstance(dbContext, orchestrations);
if (instance == null)
{
return null;
}
var execution = await dbContext.Executions
.Where(e => e.InstanceId == instance.InstanceId && e.ExecutionId == instance.LastExecutionId)
.FirstOrDefaultAsync();
var events = await dbContext.Events
.Where(e => e.InstanceId == instance.InstanceId && e.ExecutionId == instance.LastExecutionId)
.OrderBy(e => e.SequenceNumber)
.AsNoTracking()
.ToArrayAsync();
var deserializedEvents = events
.Select(e => _options.DataConverter.Deserialize <HistoryEvent>(e.Content))
.ToArray();
var runtimeState = new OrchestrationRuntimeState(deserializedEvents);
var session = new EFCoreOrchestrationSession(
_options,
_dbContextFactory,
instance,
execution,
runtimeState,
_stopCts.Token);
var messages = await session.FetchNewMessagesAsync(dbContext);
if (messages.Count == 0)
{
instance.LockId = null;
instance.LockedUntil = DateTime.UtcNow;
await dbContext.SaveChangesAsync();
return null;
}
await dbContext.SaveChangesAsync();
return new TaskOrchestrationWorkItem
{
InstanceId = instance.InstanceId,
LockedUntilUtc = instance.LockedUntil,
OrchestrationRuntimeState = runtimeState,
NewMessages = messages,
Session = session
};
}
},
r => r != null,
receiveTimeout,
_options.PollingInterval,
stoppableCancellationToken));
}
