public async Task InvokeAsync(IQueryContext context)
{
if (IsContextIncomplete(context))
{
// TODO : resources
context.Result = QueryResult.CreateError(new QueryError(
"The execute operation middleware expects the " +
"query document to be parsed and the operation to " +
"be resolved."));
}
else
{
Activity activity = _diagnosticEvents.BeginOperation(context);
try
{
IExecutionStrategy strategy = _strategyResolver
.Resolve(context.Operation.Type);
IExecutionContext executionContext =
CreateExecutionContext(context);
context.Result = await strategy.ExecuteAsync(
executionContext, executionContext.RequestAborted)
.ConfigureAwait(false);
}
finally
{
_diagnosticEvents.EndOperation(activity, context);
}
}
await _next(context).ConfigureAwait(false);
}
public async Task <TResponse> Handle(
TRequest request,
CancellationToken cancellationToken,
RequestHandlerDelegate <TResponse> next)
{
TResponse response = default(TResponse);
string typeName = typeof(TRequest).Name;
try
{
if (_dbContext.HasActiveTransaction)
{
return(await next());
}
IExecutionStrategy strategy = _dbContext.Database.CreateExecutionStrategy();
await strategy.ExecuteAsync(async() =>
{
using (IDbContextTransaction transaction = await _dbContext.BeginTransactionAsync())
{
response = await next();
await _dbContext.CommitTransactionAsync(transaction);
}
});
return(response);
}
catch (Exception)
{
throw;
}
}
public async ValueTask <bool> MoveNextAsync()
{
try
{
using (_relationalQueryContext.ConcurrencyDetector.EnterCriticalSection())
{
if (_dataReader == null)
{
if (_executionStrategy == null)
{
_executionStrategy = _relationalQueryContext.ExecutionStrategyFactory.Create();
}
await _executionStrategy.ExecuteAsync(true, InitializeReaderAsync, null, _cancellationToken).ConfigureAwait(false);
}
var hasNext = await _dataReader.ReadAsync(_cancellationToken).ConfigureAwait(false);
Current = hasNext
? _shaper(_relationalQueryContext, _dataReader.DbDataReader, _indexMap)
: default;
return(hasNext);
}
}
catch (Exception exception)
{
_queryLogger.QueryIterationFailed(_contextType, exception);
throw;
}
}
public async Task <IExecutionResult> ExecuteAsync(
OperationRequest request,
CancellationToken cancellationToken)
{
var requestTimeoutCts =
new CancellationTokenSource(_executionTimeout);
var combinedCts =
CancellationTokenSource.CreateLinkedTokenSource(
requestTimeoutCts.Token, cancellationToken);
IExecutionContext executionContext =
CreateExecutionContext(request);
try
{
return(await _strategy.ExecuteAsync(
executionContext, combinedCts.Token));
}
finally
{
executionContext.Dispose();
combinedCts.Dispose();
requestTimeoutCts.Dispose();
}
}
private async Task <ObjectResult <T> > GetResultsAsync(
MergeOption?forMergeOption, IExecutionStrategy executionStrategy, CancellationToken cancellationToken)
{
var mergeOption = forMergeOption.HasValue
? forMergeOption.Value
: QueryState.EffectiveMergeOption;
if (mergeOption != MergeOption.NoTracking)
{
QueryState.ObjectContext.AsyncMonitor.Enter();
}
try
{
return(await executionStrategy.ExecuteAsync(
() => QueryState.ObjectContext.ExecuteInTransactionAsync(
() => QueryState.GetExecutionPlan(forMergeOption)
.ExecuteAsync <T>(QueryState.ObjectContext, QueryState.Parameters, cancellationToken),
/*throwOnExistingTransaction:*/ executionStrategy.RetriesOnFailure,
/*startLocalTransaction:*/ false, /*releaseConnectionOnSuccess:*/ !QueryState.EffectiveStreamingBehaviour,
cancellationToken),
cancellationToken).ConfigureAwait(continueOnCapturedContext: false));
}
finally
{
if (mergeOption != MergeOption.NoTracking)
{
QueryState.ObjectContext.AsyncMonitor.Exit();
}
}
}
public async Task InvokeAsync(IQueryContext context)
{
if (IsContextIncomplete(context))
{
context.Result = QueryResult.CreateError(
ErrorBuilder.New()
.SetMessage(CoreResources.ExecuteOperationMiddleware_InComplete)
.SetCode(ErrorCodes.Execution.Incomplete)
.Build());
}
else
{
Activity activity = _diagnosticEvents.BeginOperation(context);
try
{
IExecutionStrategy strategy = _strategyResolver
.Resolve(context.Operation.Type);
IExecutionContext executionContext =
CreateExecutionContext(context);
context.Result = await strategy.ExecuteAsync(
executionContext, executionContext.RequestAborted)
.ConfigureAwait(false);
}
finally
{
_diagnosticEvents.EndOperation(activity, context);
}
}
await _next(context).ConfigureAwait(false);
}
public async Task <IExecutionResult> ExecuteAsync(
IReadOnlyDictionary <string, IValueNode> variableValues = null,
object initialValue = null,
CancellationToken cancellationToken = default)
{
var requestTimeoutCts =
new CancellationTokenSource(_executionTimeout);
CancellationTokenSource combinedCts =
CancellationTokenSource.CreateLinkedTokenSource(
requestTimeoutCts.Token, cancellationToken);
try
{
IExecutionContext executionContext =
CreateExecutionContext(variableValues, initialValue);
return(await _strategy.ExecuteAsync(
executionContext, combinedCts.Token));
}
finally
{
combinedCts.Dispose();
requestTimeoutCts.Dispose();
}
}
public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
await _relationalQueryContext.Connection.Semaphore.WaitAsync(cancellationToken);
if (_buffer == null)
{
if (_executionStrategy == null)
{
_executionStrategy = _relationalQueryContext.ExecutionStrategyFactory.Create();
}
return(await _executionStrategy
.ExecuteAsync(_executionStrategy.RetriesOnFailure, _bufferlessMoveNext, null, cancellationToken));
}
if (_buffer.Count > 0)
{
Current = _shaper.Shape(_relationalQueryContext, _buffer.Dequeue());
return(true);
}
return(false);
}
finally
{
_relationalQueryContext.Connection.Semaphore.Release();
}
}
public async ValueTask <bool> MoveNextAsync()
{
try
{
using (_relationalQueryContext.ConcurrencyDetector.EnterCriticalSection())
{
if (_dataReader == null)
{
if (_executionStrategy == null)
{
_executionStrategy = _relationalQueryContext.ExecutionStrategyFactory.Create();
}
await _executionStrategy.ExecuteAsync(true, InitializeReaderAsync, null, _cancellationToken);
}
var hasNext = _resultCoordinator.HasNext ?? await _dataReader.ReadAsync(_cancellationToken);
Current = default;
if (hasNext)
{
while (true)
{
_resultCoordinator.ResultReady = true;
_resultCoordinator.HasNext = null;
Current = _shaper(
_relationalQueryContext, _dataReader.DbDataReader,
_resultCoordinator.ResultContext, _indexMap, _resultCoordinator);
if (_resultCoordinator.ResultReady)
{
// We generated a result so null out previously stored values
_resultCoordinator.ResultContext.Values = null;
break;
}
if (!await _dataReader.ReadAsync(_cancellationToken))
{
_resultCoordinator.HasNext = false;
// Enumeration has ended, materialize last element
_resultCoordinator.ResultReady = true;
Current = _shaper(
_relationalQueryContext, _dataReader.DbDataReader,
_resultCoordinator.ResultContext, _indexMap, _resultCoordinator);
break;
}
}
}
return(hasNext);
}
}
catch (Exception exception)
{
_logger.QueryIterationFailed(_contextType, exception);
throw;
}
}
private async Task ExecuteTaskAsync(ICakeContext context, IExecutionStrategy strategy, Stopwatch stopWatch, CakeTask task, CakeReport report)
{
// Reset the stop watch.
stopWatch.Reset();
stopWatch.Start();
PerformTaskSetup(context, strategy, task, false);
bool exceptionWasThrown = false;
try
{
// Execute the task.
await strategy.ExecuteAsync(task, context).ConfigureAwait(false);
}
catch (Exception exception)
{
_log.Error("An error occurred when executing task '{0}'.", task.Name);
exceptionWasThrown = true;
// Got an error reporter?
if (task.ErrorReporter != null)
{
ReportErrors(strategy, task.ErrorReporter, exception);
}
// Got an error handler?
if (task.ErrorHandler != null)
{
HandleErrors(strategy, task.ErrorHandler, exception);
}
else
{
// No error handler defined for this task.
// Rethrow the exception and let it propagate.
throw;
}
}
finally
{
if (task.FinallyHandler != null)
{
strategy.InvokeFinally(task.FinallyHandler);
}
PerformTaskTeardown(context, strategy, task, stopWatch.Elapsed, false, exceptionWasThrown);
}
// Add the task results to the report
if (IsDelegatedTask(task))
{
report.AddDelegated(task.Name, stopWatch.Elapsed);
}
else
{
report.Add(task.Name, stopWatch.Elapsed);
}
}
/// <summary>
/// Executes the specified asynchronous operation.
/// </summary>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="operation">A function that returns a started task.</param>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task ExecuteAsync(
[NotNull] this IExecutionStrategy strategy,
[NotNull] Func <Task> operation)
=> strategy.ExecuteAsync(async(operationScoped, ct) =>
{
await operationScoped();
return(true);
}, operation, default(CancellationToken));
/// <summary>
/// Executes the specified asynchronous operation and returns the result.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-connection-resiliency">Connection resiliency and database retries</see>
/// for more information and examples.
/// </remarks>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="operation">
/// A function that returns a started task of type <typeparamref name="TResult" />.
/// </param>
/// <typeparam name="TResult">
/// The result type of the <see cref="Task{T}" /> returned by <paramref name="operation" />.
/// </typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task <TResult> ExecuteAsync <TResult>(
this IExecutionStrategy strategy,
Func <Task <TResult> > operation)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(operation, (operationScoped, ct) => operationScoped(), default));
}
/// <summary>
/// Run samples for Order By queries.
/// </summary>
/// <returns>a Task object.</returns>
private async Task ExecuteAsync(BenchmarkConfig config)
{
if (config.CleanupOnStart)
{
Database database = this.client.GetDatabase(config.Database);
await database.DeleteStreamAsync();
}
ContainerResponse containerResponse = await this.CreatePartitionedContainerAsync(config);
Container container = containerResponse;
int?currentContainerThroughput = await container.ReadThroughputAsync();
Console.WriteLine($"Using container {config.Container} with {currentContainerThroughput} RU/s");
int taskCount = config.GetTaskCount(currentContainerThroughput.Value);
Console.WriteLine("Starting Inserts with {0} tasks", taskCount);
Console.WriteLine();
string partitionKeyPath = containerResponse.Resource.PartitionKeyPath;
int numberOfItemsToInsert = config.ItemCount / taskCount;
string sampleItem = File.ReadAllText(config.ItemTemplateFile);
IBenchmarkOperatrion benchmarkOperation = null;
switch (config.WorkloadType.ToLower())
{
case "insert":
benchmarkOperation = new InsertBenchmarkOperation(
container,
partitionKeyPath,
sampleItem);
break;
case "read":
benchmarkOperation = new ReadBenchmarkOperation(
container,
partitionKeyPath,
sampleItem);
break;
default:
throw new NotImplementedException($"Unsupported workload type {config.WorkloadType}");
}
IExecutionStrategy execution = IExecutionStrategy.StartNew(config, benchmarkOperation);
await execution.ExecuteAsync(taskCount, numberOfItemsToInsert, 0.01);
if (config.CleanupOnFinish)
{
Console.WriteLine($"Deleting Database {config.Database}");
Database database = this.client.GetDatabase(config.Database);
await database.DeleteStreamAsync();
}
}
/// <summary>
/// Executes the specified asynchronous operation.
/// </summary>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="operation">A function that returns a started task.</param>
/// <param name="state">The state that will be passed to the operation.</param>
/// <typeparam name="TState">The type of the state.</typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task ExecuteAsync <TState>(
[NotNull] this IExecutionStrategy strategy,
[NotNull] Func <TState, Task> operation,
[CanBeNull] TState state)
=> strategy.ExecuteAsync(async(t, ct) =>
{
await t.operation(t.state);
return(true);
}, new { operation, state }, default(CancellationToken));
/// <summary>
/// Executes the specified asynchronous operation and returns the result.
/// </summary>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="state">The state that will be passed to the operation.</param>
/// <param name="operation">
/// A function that returns a started task of type <typeparamref name="TResult" />.
/// </param>
/// <typeparam name="TState">The type of the state.</typeparam>
/// <typeparam name="TResult">
/// The result type of the <see cref="Task{T}" /> returned by <paramref name="operation" />.
/// </typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task <TResult> ExecuteAsync <TState, TResult>(
[NotNull] this IExecutionStrategy strategy,
[CanBeNull] TState state,
[NotNull] Func <TState, Task <TResult> > operation)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(new { operation, state }, (t, ct) => t.operation(t.state), default));
}
/// <summary>
/// Executes the specified asynchronous operation and returns the result.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-connection-resiliency">Connection resiliency and database retries</see>
/// for more information and examples.
/// </remarks>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="operation">
/// A function that returns a started task of type <typeparamref name="TResult" />.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token used to cancel the retry operation, but not operations that are already in flight
/// or that already completed successfully.
/// </param>
/// <typeparam name="TResult">
/// The result type of the <see cref="Task{T}" /> returned by <paramref name="operation" />.
/// </typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
/// <exception cref="OperationCanceledException">If the <see cref="CancellationToken" /> is canceled.</exception>
public static Task <TResult> ExecuteAsync <TResult>(
this IExecutionStrategy strategy,
Func <CancellationToken, Task <TResult> > operation,
CancellationToken cancellationToken)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(operation, (operationScoped, ct) => operationScoped(ct), cancellationToken));
}
private async Task ExecuteTaskAsync(ICakeContext context, IExecutionStrategy strategy, CancellationTokenSource cts, CakeTask task, CakeReport report)
{
_log.Verbose($"Starting task {task.Name}");
var stopwatch = Stopwatch.StartNew();
PerformTaskSetup(context, strategy, task, false);
var execptionWasThrown = false;
try
{
var taskExecutionContext = new TaskExecutionContext(context, task);
await strategy.ExecuteAsync(task, taskExecutionContext).ConfigureAwait(false);
}
catch (TaskCanceledException)
{
execptionWasThrown = true;
throw;
}
catch (Exception exception)
{
execptionWasThrown = true;
_log.Error($"An error occurred when executing task '{task.Name}'.");
if (task.ErrorReporter != null)
{
ReportErrors(strategy, task.ErrorReporter, exception);
}
if (task.ErrorHandler != null)
{
HandleErrors(strategy, task.ErrorHandler, exception);
}
else
{
cts.Cancel();
throw;
}
}
finally
{
strategy.InvokeFinally(task.FinallyHandler);
PerformTaskTeardown(context, strategy, task, stopwatch.Elapsed, false, execptionWasThrown);
}
if (isDelegatedTask(task))
{
report.AddDelegated(task.Name, stopwatch.Elapsed);
}
else
{
report.Add(task.Name, stopwatch.Elapsed);
}
}
/// <summary>
/// Executes the specified asynchronous operation in a transaction and returns the result. Allows to check whether
/// the transaction has been rolled back if an error occurs during commit.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-connection-resiliency">Connection resiliency and database retries</see>
/// for more information and examples.
/// </remarks>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="state">The state that will be passed to the operation.</param>
/// <param name="operation">
/// A function that returns a started task of type <typeparamref name="TResult" />.
/// </param>
/// <param name="verifySucceeded">
/// A delegate that tests whether the operation succeeded even though an exception was thrown when the
/// transaction was being committed.
/// </param>
/// <param name="beginTransaction">A delegate that begins a transaction using the given context.</param>
/// <param name="cancellationToken">
/// A cancellation token used to cancel the retry operation, but not operations that are already in flight
/// or that already completed successfully.
/// </param>
/// <typeparam name="TState">The type of the state.</typeparam>
/// <typeparam name="TResult">The result type of the <see cref="Task{T}" /> returned by <paramref name="operation" />.</typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
/// <exception cref="RetryLimitExceededException">
/// The operation has not succeeded after the configured number of retries.
/// </exception>
/// <exception cref="OperationCanceledException">If the <see cref="CancellationToken" /> is canceled.</exception>
public static Task <TResult> ExecuteInTransactionAsync <TState, TResult>(
IExecutionStrategy strategy,
TState state,
Func <TState, CancellationToken, Task <TResult> > operation,
Func <TState, CancellationToken, Task <bool> > verifySucceeded,
Func <DbContext, CancellationToken, Task <IDbContextTransaction> > beginTransaction,
CancellationToken cancellationToken = default)
=> strategy.ExecuteAsync(
new ExecutionStateAsync <TState, TResult>(
Check.NotNull(operation, nameof(operation)), Check.NotNull(verifySucceeded, nameof(verifySucceeded)), state),
async(c, s, ct) =>
/// <summary>
/// Executes the specified asynchronous operation and returns the result.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-connection-resiliency">Connection resiliency and database retries</see>
/// for more information and examples.
/// </remarks>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="state">The state that will be passed to the operation.</param>
/// <param name="operation">
/// A function that returns a started task of type <typeparamref name="TResult" />.
/// </param>
/// <param name="verifySucceeded">A delegate that tests whether the operation succeeded even though an exception was thrown.</param>
/// <param name="cancellationToken">
/// A cancellation token used to cancel the retry operation, but not operations that are already in flight
/// or that already completed successfully.
/// </param>
/// <typeparam name="TState">The type of the state.</typeparam>
/// <typeparam name="TResult">The result type of the <see cref="Task{T}" /> returned by <paramref name="operation" />.</typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
/// <exception cref="RetryLimitExceededException">
/// The operation has not succeeded after the configured number of retries.
/// </exception>
/// <exception cref="OperationCanceledException">If the <see cref="CancellationToken" /> is canceled.</exception>
public static Task <TResult> ExecuteAsync <TState, TResult>(
this IExecutionStrategy strategy,
TState state,
Func <TState, CancellationToken, Task <TResult> > operation,
Func <TState, CancellationToken, Task <ExecutionResult <TResult> > >?verifySucceeded,
CancellationToken cancellationToken = default)
=> strategy.ExecuteAsync(
state,
(c, s, ct) => operation(s, ct),
verifySucceeded == null
? null
: (c, s, ct) => verifySucceeded(s, ct), cancellationToken);
/// <summary>
/// Executes the specified asynchronous operation.
/// </summary>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="operation">A function that returns a started task.</param>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task ExecuteAsync(
[NotNull] this IExecutionStrategy strategy,
[NotNull] Func <Task> operation)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(operation, async(operationScoped, ct) =>
{
await operationScoped();
return true;
}, default(CancellationToken)));
}
/// <summary>
/// Executes the specified asynchronous operation.
/// </summary>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="state">The state that will be passed to the operation.</param>
/// <param name="operation">A function that returns a started task.</param>
/// <typeparam name="TState">The type of the state.</typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task ExecuteAsync <TState>(
[NotNull] this IExecutionStrategy strategy,
[CanBeNull] TState state,
[NotNull] Func <TState, Task> operation)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(new { operation, state }, async(t, ct) =>
{
await t.operation(t.state);
return true;
}, default(CancellationToken)));
}
/// <summary>
/// Executes the specified asynchronous operation.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-connection-resiliency">Connection resiliency and database retries</see>
/// for more information and examples.
/// </remarks>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="operation">A function that returns a started task.</param>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task ExecuteAsync(
this IExecutionStrategy strategy,
Func <Task> operation)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(
operation, async(operationScoped, ct) =>
{
await operationScoped().ConfigureAwait(false);
return true;
}, default));
}
public async Task InvokeAsync(IQueryContext context)
{
if (IsContextValid(context))
{
IExecutionStrategy strategy =
_strategyResolver.Resolve(context.Operation.Operation);
IExecutionContext execContext =
CreateExecutionContext(context);
context.Result = await strategy.ExecuteAsync(
execContext, execContext.RequestAborted);
}
await _next(context);
}
/// <summary>
/// Executes the specified asynchronous operation.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-connection-resiliency">Connection resiliency and database retries</see>
/// for more information and examples.
/// </remarks>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="state">The state that will be passed to the operation.</param>
/// <param name="operation">A function that returns a started task.</param>
/// <typeparam name="TState">The type of the state.</typeparam>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
public static Task ExecuteAsync <TState>(
this IExecutionStrategy strategy,
TState state,
Func <TState, Task> operation)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(
new { operation, state }, async(t, ct) =>
{
await t.operation(t.state).ConfigureAwait(false);
return true;
}, default));
}
/// <summary>
/// Executes the specified asynchronous operation.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-connection-resiliency">Connection resiliency and database retries</see>
/// for more information and examples.
/// </remarks>
/// <param name="strategy">The strategy that will be used for the execution.</param>
/// <param name="operation">A function that returns a started task.</param>
/// <param name="cancellationToken">
/// A cancellation token used to cancel the retry operation, but not operations that are already in flight
/// or that already completed successfully.
/// </param>
/// <returns>
/// A task that will run to completion if the original task completes successfully (either the
/// first time or after retrying transient failures). If the task fails with a non-transient error or
/// the retry limit is reached, the returned task will become faulted and the exception must be observed.
/// </returns>
/// <exception cref="OperationCanceledException">If the <see cref="CancellationToken" /> is canceled.</exception>
public static Task ExecuteAsync(
this IExecutionStrategy strategy,
Func <CancellationToken, Task> operation,
CancellationToken cancellationToken)
{
Check.NotNull(operation, nameof(operation));
return(strategy.ExecuteAsync(
operation, async(operationScoped, ct) =>
{
await operationScoped(ct).ConfigureAwait(false);
return true;
}, cancellationToken));
}
public async Task ExecuteAsync(Func <Task> action)
{
//Use of an EF Core resiliency strategy when using multiple DbContexts within an explicit BeginTransaction():
//See: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
IExecutionStrategy strategy = _dbContext.Database.CreateExecutionStrategy();
await strategy.ExecuteAsync(async() =>
{
using (IDbContextTransaction transaction = _dbContext.Database.BeginTransaction())
{
await action();
transaction.Commit();
}
});
}
public static async Task ExecuteAsync <T>(
this IDatabaseContextFactory <T> contextFactory,
Func <IDatabaseContextFactory <T>, Task> operation)
where T : DbContext
{
using (var context = contextFactory.Create())
{
IExecutionStrategy strategy = context.Database.CreateExecutionStrategy();
await strategy.ExecuteAsync(async() =>
{
await operation(contextFactory);
});
}
}
/// <summary>
/// Executes the specified task.
/// </summary>
/// <param name="task">The task to execute.</param>
/// <param name="context">The context.</param>
/// <returns>Returned Task</returns>
public Task ExecuteAsync(CakeTask task, ICakeContext context)
{
if (task == null)
{
return(Task.CompletedTask);
}
if (_exclusiveTaskName != null && _exclusiveTaskName != task.Name)
{
_default.Skip(task, new CakeTaskCriteria(ctx => true, null));
return(Task.CompletedTask);
}
return(_default.ExecuteAsync(task, context));
}
public async Task <ExecutionResult> ExecuteAsync(ExecutionContext context)
{
var key = typeof(IDependencyInjector).FullName ?? nameof(IDependencyInjector);
var outerInjector = context.UserContext[key];
try
{
context.UserContext[key] = _injector;
return(await _innerStrategy.ExecuteAsync(context));
}
finally
{
context.UserContext[key] = outerInjector;
}
}
public async Task <ExecutionResult> ExecuteAsync(ExecutionContext context)
{
var outerUserContextWrapper = context.UserContext;
var userContext = (context.UserContext as IUserContextAccessor)?.UserContext;
try
{
context.UserContext = UserContextWrapper.Create(userContext, _injector);
return(await _innerStrategy.ExecuteAsync(context));
}
finally
{
context.UserContext = outerUserContextWrapper;
}
}
