protected RelationalDataStore(
[NotNull] IModel model,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IEntityMaterializerSource entityMaterializerSource,
[NotNull] IRelationalConnection connection,
[NotNull] CommandBatchPreparer batchPreparer,
[NotNull] BatchExecutor batchExecutor,
[NotNull] IDbContextOptions options,
[NotNull] ILoggerFactory loggerFactory)
: base(
Check.NotNull(model, nameof(model)),
Check.NotNull(entityKeyFactorySource, nameof(entityKeyFactorySource)),
Check.NotNull(entityMaterializerSource, nameof(entityMaterializerSource)),
Check.NotNull(loggerFactory, nameof(loggerFactory)))
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(batchPreparer, nameof(batchPreparer));
Check.NotNull(batchExecutor, nameof(batchExecutor));
Check.NotNull(options, nameof(options));
_batchPreparer = batchPreparer;
_batchExecutor = batchExecutor;
_connection = connection;
_options = options;
}
public RequestExecutor(
ISchema schema,
IServiceProvider applicationServices,
IServiceProvider executorServices,
IErrorHandler errorHandler,
ITypeConverter converter,
IActivator activator,
IDiagnosticEvents diagnosticEvents,
RequestDelegate requestDelegate)
{
Schema = schema ??
throw new ArgumentNullException(nameof(schema));
_services = applicationServices ??
throw new ArgumentNullException(nameof(applicationServices));
Services = executorServices ??
throw new ArgumentNullException(nameof(executorServices));
_errorHandler = errorHandler ??
throw new ArgumentNullException(nameof(errorHandler));
_converter = converter ??
throw new ArgumentNullException(nameof(converter));
_activator = activator ??
throw new ArgumentNullException(nameof(activator));
_diagnosticEvents = diagnosticEvents ??
throw new ArgumentNullException(nameof(diagnosticEvents));
_requestDelegate = requestDelegate ??
throw new ArgumentNullException(nameof(requestDelegate));
_batchExecutor = new BatchExecutor(this, errorHandler, converter);
}
public async Task ExecuteAsync_calls_Commit_if_no_transaction()
{
var mockModificationCommandBatch = new Mock <ModificationCommandBatch>();
mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1);
var mockRelationalConnection = new Mock <IRelationalConnection>();
var transactionMock = new Mock <IDbContextTransaction>();
IDbContextTransaction currentTransaction = null;
mockRelationalConnection.Setup(m => m.BeginTransaction()).Returns(() => currentTransaction = transactionMock.Object);
mockRelationalConnection.Setup(m => m.CurrentTransaction).Returns(() => currentTransaction);
var cancellationToken = new CancellationTokenSource().Token;
var batchExecutor = new BatchExecutor();
await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken);
mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken));
mockRelationalConnection.Verify(rc => rc.Close());
transactionMock.Verify(t => t.Commit());
mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync(
It.IsAny <IRelationalConnection>(),
cancellationToken));
}
public async Task ExecuteAsync_does_not_call_Commit_if_existing_transaction()
{
var mockModificationCommandBatch = new Mock <ModificationCommandBatch>();
mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1);
var mockRelationalConnection = new Mock <IRelationalConnection>();
var transactionMock = new Mock <IDbContextTransaction>();
mockRelationalConnection.Setup(m => m.CurrentTransaction).Returns(transactionMock.Object);
var cancellationToken = new CancellationTokenSource().Token;
var batchExecutor = new BatchExecutor(
new CurrentDbContext(new DbContext(new DbContextOptionsBuilder().Options)), new ExecutionStrategyFactory());
await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken);
mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken));
mockRelationalConnection.Verify(rc => rc.Close());
mockRelationalConnection.Verify(rc => rc.BeginTransaction(), Times.Never);
transactionMock.Verify(t => t.Commit(), Times.Never);
mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync(
It.IsAny <IRelationalConnection>(),
cancellationToken));
}
protected RelationalDataStore(
[NotNull] StateManager stateManager,
[NotNull] DbContextService <IModel> model,
[NotNull] EntityKeyFactorySource entityKeyFactorySource,
[NotNull] EntityMaterializerSource entityMaterializerSource,
[NotNull] ClrCollectionAccessorSource collectionAccessorSource,
[NotNull] ClrPropertySetterSource propertySetterSource,
[NotNull] RelationalConnection connection,
[NotNull] CommandBatchPreparer batchPreparer,
[NotNull] BatchExecutor batchExecutor,
[NotNull] DbContextService <IDbContextOptions> options,
[NotNull] ILoggerFactory loggerFactory)
: base(stateManager, model, entityKeyFactorySource, entityMaterializerSource,
collectionAccessorSource, propertySetterSource, loggerFactory)
{
Check.NotNull(connection, "connection");
Check.NotNull(batchPreparer, "batchPreparer");
Check.NotNull(batchExecutor, "batchExecutor");
Check.NotNull(options, "options");
_batchPreparer = batchPreparer;
_batchExecutor = batchExecutor;
_connection = connection;
_options = options.Service;
}
public RequestExecutor(
ISchema schema,
DefaultRequestContextAccessor requestContextAccessor,
IServiceProvider applicationServices,
IServiceProvider executorServices,
RequestDelegate requestDelegate,
BatchExecutor batchExecutor,
ObjectPool <RequestContext> contextPool,
ulong version)
{
Schema = schema ??
throw new ArgumentNullException(nameof(schema));
_requestContextAccessor = requestContextAccessor ??
throw new ArgumentNullException(nameof(requestContextAccessor));
_applicationServices = applicationServices ??
throw new ArgumentNullException(nameof(applicationServices));
Services = executorServices ??
throw new ArgumentNullException(nameof(executorServices));
_requestDelegate = requestDelegate ??
throw new ArgumentNullException(nameof(requestDelegate));
_batchExecutor = batchExecutor ??
throw new ArgumentNullException(nameof(batchExecutor));
_contextPool = contextPool ??
throw new ArgumentNullException(nameof(contextPool));
Version = version;
}
public async Task ExecAsync_ProcessQueue_QueueProcessedInCorrectOrder()
{
using (var batchExecutor = new BatchExecutor <int, string>(5, async items =>
{
await Task.Delay(10);
var dictionary = items.ToDictionary(i => i, i => i.ToString());
return(dictionary);
}, TimeSpan.FromMilliseconds(50)))
{
var errorsOccurs = false;
var tasks = new List <Task <string> >();
try
{
const int maxSteps = 17;
for (var i = 0; i < maxSteps; i++)
{
tasks.Add(batchExecutor.ExecAsync(i));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
for (var i = 0; i < maxSteps; i++)
{
Assert.AreEqual(i.ToString(), tasks[i].Result);
}
}
catch (Exception)
{
errorsOccurs = true;
}
Assert.AreEqual(false, errorsOccurs);
}
}
public async Task ExecAsync_BufferFull_ProcessedImmediately()
{
var flushInterval = TimeSpan.FromMilliseconds(10000);
var batchSize = 50;
using (var batchExecutor = new BatchExecutor <int, string>(batchSize, async items =>
{
await Task.Delay(1);
var dictionary = items.ToDictionary(i => i, i => i.ToString());
return(dictionary);
}, flushInterval))
{
var sw = Stopwatch.StartNew();
var tasks = new List <Task>();
for (var i = 0; i < batchSize; i++)
{
tasks.Add(batchExecutor.ExecAsync(i));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
sw.Stop();
Console.WriteLine($"Timer: {flushInterval}, elapsed: {sw.Elapsed}");
var deviation = 50 / 100 * 50;
Assert.IsTrue(sw.Elapsed.TotalMilliseconds <= flushInterval.TotalMilliseconds + deviation);
}
}
public async Task ExecuteAsync_calls_Commit_if_no_transaction()
{
var mockModificationCommandBatch = new Mock<ModificationCommandBatch>();
mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1);
var mockRelationalConnection = new Mock<IRelationalConnection>();
var transactionMock = new Mock<IRelationalTransaction>();
IRelationalTransaction currentTransaction = null;
mockRelationalConnection.Setup(m => m.BeginTransaction()).Returns(() => currentTransaction = transactionMock.Object);
mockRelationalConnection.Setup(m => m.Transaction).Returns(() => currentTransaction);
var cancellationToken = new CancellationTokenSource().Token;
var batchExecutor = new BatchExecutor();
await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken);
mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken));
mockRelationalConnection.Verify(rc => rc.Close());
transactionMock.Verify(t => t.Commit());
mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync(
It.IsAny<IRelationalConnection>(),
cancellationToken));
}
public FakeRelationalDataStore(
DbContextConfiguration configuration,
RelationalConnection connection,
CommandBatchPreparer batchPreparer,
BatchExecutor batchExecutor)
: base(configuration, connection, batchPreparer, batchExecutor)
{
}
public FakeRelationalDataStore(
IModel model,
IEntityKeyFactorySource entityKeyFactorySource,
IEntityMaterializerSource entityMaterializerSource,
IRelationalConnection connection,
CommandBatchPreparer batchPreparer,
BatchExecutor batchExecutor,
IDbContextOptions options,
ILoggerFactory loggerFactory)
: base(model, entityKeyFactorySource, entityMaterializerSource, connection, batchPreparer, batchExecutor, options, loggerFactory)
{
}
public FakeRelationalDataStore(
StateManager stateManager,
DbContextService <IModel> model,
EntityKeyFactorySource entityKeyFactorySource,
EntityMaterializerSource entityMaterializerSource,
ClrCollectionAccessorSource collectionAccessorSource,
ClrPropertySetterSource propertySetterSource,
RelationalConnection connection,
CommandBatchPreparer batchPreparer,
BatchExecutor batchExecutor,
ILoggerFactory loggerFactory)
: base(stateManager, model, entityKeyFactorySource, entityMaterializerSource,
collectionAccessorSource, propertySetterSource, connection, batchPreparer, batchExecutor, loggerFactory)
{
}
protected RelationalDataStore(
[NotNull] DbContextConfiguration configuration,
[NotNull] RelationalConnection connection,
[NotNull] CommandBatchPreparer batchPreparer,
[NotNull] BatchExecutor batchExecutor)
: base(configuration)
{
Check.NotNull(connection, "connection");
Check.NotNull(batchPreparer, "batchPreparer");
Check.NotNull(batchExecutor, "batchExecutor");
_batchPreparer = batchPreparer;
_batchExecutor = batchExecutor;
_connection = connection;
}
public async Task ExecAsync_ManyTasks_AllCompletedSuccessfully()
{
var batchExecutor = new BatchExecutor <int, string>(157, ExecOnExternalStorageAsync, TimeSpan.FromMilliseconds(51));
var tasks = new List <Task>();
const int loopCount = 1800053;
var startCounter = 0;
var finishCounter = 0;
var sw = Stopwatch.StartNew();
try
{
for (var i = 1; i <= loopCount; i++)
{
//await ExecOnExternalStorageAsync(items);
var i1 = i;
tasks.Add(Task.Run(async() =>
{
Interlocked.Increment(ref startCounter);
try
{
var result = await batchExecutor.ExecAsync(i1).ConfigureAwait(false);
return(result);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
Interlocked.Increment(ref finishCounter);
}
}));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
sw.Stop();
Console.WriteLine("Elapsed: {0}", sw.Elapsed);
Assert.AreEqual(startCounter, finishCounter);
}
public async void Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values()
{
var stateEntry = CreateStateEntry(EntityState.Added, ValueGenerationOnSave.WhenInserting);
var command = new ModificationCommand("T1", new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var batch = new ModificationCommandBatch(new[] { command });
var mockReader = SetupMockDataReader(new[] { "Col1" });
var connection = SetupMockConnection(mockReader.Object);
var executor = new BatchExecutor(new Mock <SqlGenerator> {
CallBase = true
}.Object, connection, new RelationalTypeMapper());
Assert.Equal(Strings.FormatUpdateConcurrencyException(1, 0),
(await Assert.ThrowsAsync <DbUpdateConcurrencyException>(
async() => await executor.ExecuteAsync(new[] { batch }))).Message);
}
public async Task ExecAsync_ActionTrowsException_ExceptionCatchedByAwait()
{
using (var batchExecutor = new BatchExecutor <int, string>(5, async items =>
{
await Task.Delay(10);
throw new Exception("Exception in action");
}, TimeSpan.FromMilliseconds(50)))
{
var catched = false;
try
{
await batchExecutor.ExecAsync(1).ConfigureAwait(false);
}
catch (Exception)
{
catched = true;
}
Assert.AreEqual(true, catched);
}
}
public async void ExecuteAsync_executes_batch_commands_and_consumes_reader()
{
var stateEntry = CreateStateEntry(EntityState.Added);
var command = new ModificationCommand("T1", new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var batch = new ModificationCommandBatch(new[] { command });
var mockReader = SetupMockDataReader();
var connection = SetupMockConnection(mockReader.Object);
var executor = new BatchExecutor(new Mock <SqlGenerator> {
CallBase = true
}.Object, connection, new RelationalTypeMapper());
await executor.ExecuteAsync(new[] { batch });
mockReader.Verify(r => r.ReadAsync(It.IsAny <CancellationToken>()), Times.Once);
mockReader.Verify(r => r.NextResultAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public async Task ExecAsync_BufferNotFull_ProcessedByTimer()
{
var flushInterval = TimeSpan.FromMilliseconds(100);
using (var batchExecutor = new BatchExecutor <int, string>(500, async items =>
{
await Task.Delay(1);
var dictionary = items.ToDictionary(i => i, i => i.ToString());
return(dictionary);
}, flushInterval))
{
var sw = Stopwatch.StartNew();
var result = await batchExecutor.ExecAsync(1).ConfigureAwait(false);
sw.Stop();
Console.WriteLine($"Timer: {flushInterval}, elapsed: {sw.Elapsed}");
Assert.AreEqual("1", result);
var deviation = flushInterval.TotalMilliseconds / 100 * 50;
Assert.IsTrue(sw.Elapsed.TotalMilliseconds <= flushInterval.TotalMilliseconds + deviation);
}
}
public async Task Dispose_QueueNotFull_FlushedSuccessfully()
{
var batchExecutor = new BatchExecutor <int, string>(50, async items =>
{
await Task.Delay(10);
var dictionary = items.ToDictionary(i => i, i => i.ToString());
return(dictionary);
}, TimeSpan.FromHours(1));
var tasks = new List <Task <string> >();
const int loopCount = 11;
for (var i = 1; i <= loopCount; i++)
{
tasks.Add(batchExecutor.ExecAsync(i));
}
EnsureTaskStatus(loopCount, tasks, TaskStatus.WaitingForActivation, false);
batchExecutor.Dispose();
await Task.WhenAll(tasks).ConfigureAwait(false);
EnsureTaskStatus(loopCount, tasks, TaskStatus.RanToCompletion, true);
}
public async Task ExecAsync_ActionTrowsException_AllTasksInBatchHasSameException()
{
using (var batchExecutor = new BatchExecutor <int, string>(5, async items =>
{
await Task.Delay(1);
var dictionary = items.ToDictionary(i => 411, i => i.ToString());
return(dictionary);
}, TimeSpan.FromMilliseconds(50)))
{
var tasks = new List <Task>();
for (var i = 0; i < 7; i++)
{
tasks.Add(batchExecutor.ExecAsync(i));
}
var catched = false;
try
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception)
{
catched = true;
}
Assert.AreEqual(true, catched);
Task tmp = null;
foreach (var task in tasks)
{
if (tmp == null)
{
tmp = task;
}
else
{
Debug.Assert(tmp.Exception != null, "tmp.Exception != null");
Debug.Assert(task.Exception != null, "task.Exception != null");
Assert.AreEqual(tmp.Exception.Message, task.Exception.Message);
}
}
}
}
public async Task ExecuteAsync_does_not_call_Commit_if_existing_transaction()
{
var mockModificationCommandBatch = new Mock <ModificationCommandBatch>();
var transactionMock = new Mock <RelationalTransaction>();
var mockRelationalConnection = new Mock <RelationalConnection>();
mockRelationalConnection.Setup(m => m.Transaction).Returns(transactionMock.Object);
var cancellationToken = new CancellationTokenSource().Token;
var relationalTypeMapper = new RelationalTypeMapper();
var batchExecutor = new BatchExecutor(relationalTypeMapper);
await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken);
mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken));
mockRelationalConnection.Verify(rc => rc.Close());
mockRelationalConnection.Verify(rc => rc.BeginTransaction(), Times.Never);
transactionMock.Verify(t => t.Commit(), Times.Never);
mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync(It.IsAny <RelationalTransaction>(), relationalTypeMapper, cancellationToken));
}
public async void ExecuteAsync_saves_store_generated_values()
{
var stateEntry = CreateStateEntry(EntityState.Added, ValueGenerationOnSave.WhenInserting);
var command = new ModificationCommand("T1", new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var batch = new ModificationCommandBatch(new[] { command });
var mockReader = SetupMockDataReader(new[] { "Col1" }, new List <object[]> {
new object[] { 42 }
});
var connection = SetupMockConnection(mockReader.Object);
var executor = new BatchExecutor(new Mock <SqlGenerator> {
CallBase = true
}.Object, connection, new RelationalTypeMapper());
await executor.ExecuteAsync(new[] { batch });
Assert.Equal(42, stateEntry[stateEntry.EntityType.GetProperty("Col1")]);
Assert.Equal("Test", stateEntry[stateEntry.EntityType.GetProperty("Col2")]);
}
public async void Exception_thrown_for_more_than_one_row_returned_for_single_command()
{
var stateEntry = CreateStateEntry(EntityState.Added, ValueGenerationOnSave.WhenInserting);
var command = new ModificationCommand("T1", new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var batch = new ModificationCommandBatch(new[] { command });
var mockReader = SetupMockDataReader(new[] { "Col1" }, new List <object[]>
{
new object[] { 42 },
new object[] { 43 }
});
var connection = SetupMockConnection(mockReader.Object);
var executor = new BatchExecutor(new Mock <SqlGenerator> {
CallBase = true
}.Object, connection, new RelationalTypeMapper());
Assert.Equal(Strings.TooManyRowsForModificationCommand,
(await Assert.ThrowsAsync <DbUpdateException>(
async() => await executor.ExecuteAsync(new[] { batch }))).Message);
}
public async Task ExecAsync_LoadTesting_OK()
{
var batchExecutor = new BatchExecutor <int, string>(5, async items =>
{
await Task.Delay(1);
var dictionary = items.ToDictionary(i => i, i => i.ToString());
return(dictionary);
}, TimeSpan.FromMilliseconds(50));
var tasks = new List <Task>();
const int loopCount = 1000;
for (var i = 1; i <= loopCount; i++)
{
var i1 = i;
tasks.Add(Task.Run(async() =>
{
var result = await batchExecutor.ExecAsync(i1).ConfigureAwait(false);
Assert.AreEqual(i1.ToString(), result);
return(result);
}));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
}
/// <summary>
/// Starts the processing of a batch and returns results when processing is completed.
/// </summary>
/// <returns>Document processing results.</returns>
public IEnumerable<BatchComprenoTaskResult> RunAndWaitResults()
{
_connectionLimitValidator.ThrowIfNotEnough(DegreeOfParallelism);
ISourceProcessor sourceProcessor = createSourceProcessor();
BatchExecutor executor = new BatchExecutor(_sources, sourceProcessor, OnProgressChanged);
return executor.Execute(DegreeOfParallelism, Timeout, CancellationToken);
}
public QueueSender(BrokerGroupService brokerGroupService)
{
_brokerGroupService = brokerGroupService;
_queue = new BatchExecutor <ProducerMessageImpl>("qmq-sender", 30, DoSend, 4);
}
