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