public DbEntityResolver(Options?options, IServiceProvider services) : base(services)
{
options ??= new();
BatchProcessorFactory = options.BatchProcessorFactory ??
(self => new AsyncBatchProcessor <TKey, TEntity> {
MaxBatchSize = 16,
ConcurrencyLevel = Math.Min(HardwareInfo.ProcessorCount, 4),
BatchingDelayTaskFactory = cancellationToken => Task.Delay(1, cancellationToken),
BatchProcessor = self.ProcessBatch,
});
_batchProcessorLazy = new Lazy <AsyncBatchProcessor <TKey, TEntity> >(
() => BatchProcessorFactory.Invoke(this));
using var dbContext = CreateDbContext();
var entityType = dbContext.Model.FindEntityType(typeof(TEntity));
var key = entityType.FindPrimaryKey();
KeyExtractorExpressionBuilder = options.KeyExtractorExpressionBuilder ??
(eEntity => Expression.PropertyOrField(eEntity, key.Properties.Single().Name));
var pEntity = Expression.Parameter(typeof(TEntity), "e");
var eBody = KeyExtractorExpressionBuilder.Invoke(pEntity);
KeyExtractor = (Func <TEntity, TKey>)Expression.Lambda(eBody, pEntity).Compile();
QueryTransformer = options.QueryTransformer ?? (q => q);
PostProcessor = options.PostProcessor ?? (_ => {});
}
public void ImportSyncAndExportFromTwoSourcesTest()
{
lock (TrioWing)
{
LoggerMock.LogRepository.Clear();
var kernel = BatchProcessorFactory.GetKernel <CoordinatedData>();
WaitForCompleation(kernel);
var task = kernel.GetConnector("EmailImporter").ExecuteConnector(ExecutionTypes.Full);
var task1 = kernel.GetConnector("ImportFirstLastName").ExecuteConnector(ExecutionTypes.Full);
Task.WaitAll(task, task1);
Assert.AreNotEqual(task.Result.ProcessedItems, task1.Result.ProcessedItems);
var task2 = kernel.GetConnector("Synchronizer").ExecuteConnector(ExecutionTypes.Full);
task2.Wait();
var task3 = kernel.GetConnector("Exporter").ExecuteConnector(ExecutionTypes.Full);
task3.Wait();
Assert.AreEqual(10, MemoryRepository.Repository.Count);
Assert.IsNotNull(MemoryRepository.Repository.First().Value.MasterItem);
Assert.AreEqual(10, Exporter.ExportedItems.Count);
Assert.AreEqual(10, LoggerMock.LogRepository[task3.Result.RunId].ProcessedItems);
Assert.AreEqual(10, LoggerMock.LogRepository[task3.Result.RunId].Progress.Count);
Assert.AreEqual(4, kernel.GetLogger().GetLastLogItems(100, false).Count());
Assert.AreEqual(task3.Result.ProcessedItems, kernel.GetLogger().GetLogItemHeader(task3.Result.RunId).ProcessedItems);
Assert.AreEqual(10, kernel.GetLogger().GetProcessRecords(task3.Result.RunId, 0, false).Items.Count());
Assert.AreEqual(0, kernel.GetLogger().GetProcessRecords(task3.Result.RunId, 0, true).Items.Count());
}
}
public void ImportStartAndTerminate()
{
lock (TrioWing)
{
var kernel = BatchProcessorFactory.GetKernel <CoordinatedData>();
IBatchConnector <CoordinatedData> emailConnector = null;
try
{
emailConnector = kernel.GetConnector("EmailImporter");
var task = emailConnector.ExecuteConnector(ExecutionTypes.Full);
Thread.Sleep(50);
kernel.TerminateAllConnectors();
Task.WaitAll(task);
Assert.IsFalse(kernel.GetLogger().GetLogItemHeader(task.Result.RunId).Success);
}
catch (AggregateException ex)
{
Assert.IsFalse(kernel.GetLogger().GetLogItemHeader(emailConnector.RunId).Success);
Assert.IsInstanceOfType(ex.InnerException, typeof(InvalidAsynchronousStateException));
}
catch (Exception ex)
{
Assert.IsFalse(kernel.GetLogger().GetLogItemHeader(emailConnector.RunId).Success);
Assert.IsInstanceOfType(ex, typeof(InvalidAsynchronousStateException));
}
}
}
public bool IsConnectorRunning(string name)
{
Initialize(string.Format("IsConnectorRunning({0})", name));
var result = BatchProcessorFactory.GetKernel <T>().IsSynchronizerRunning(name);
TearDown();
return(result);
}
public IDictionary <string, ConnectorTypes> GetConnectors()
{
Initialize("GetConnectors");
var result = BatchProcessorFactory.GetKernel <T>().GetConnectors();
TearDown();
return(result);
}
public void Initialize()
{
ContainerFactory.Current.KillAllInstances();
KernelScope = Resolver.BeginKernelScope();
Resolver.LoadModuleConfiguration <Blueprint>();
BatchProcessorFactory.BindKernel <CoordinatedData>()
.SetBatchRepository <MemoryRepository>()
.SetLogger <LoggerMock>()
.SetCoordinator <ImportFirstLastName>()
.SetCoordinator <EmailImporter>()
.SetCoordinator <Synchronizer>()
.SetCoordinator <Exporter>();
}
public bool Terminate(string name)
{
Initialize(string.Format("Terminate({0})", name));
bool result;
try
{
result = BatchProcessorFactory.GetKernel <T>().TerminateConnector(name);
}
catch (Exception ex)
{
Tracer.SetErrorState(ex);
Tracer.SetAdidtionalInformation("Unable to terminate connectors");
result = false;
}
TearDown();
return(result);
}
public string StartConnector(string name, ExecutionTypes executionType)
{
Initialize(string.Format("StartConnector({0})", name));
IBatchConnector <T> task;
try
{
task = BatchProcessorFactory.GetKernel <T>().GetConnector(name);
task.ExecuteConnector(executionType);
}
catch (Exception ex)
{
Tracer.SetAdidtionalInformation(ex.Message);
Tracer.SetErrorState(ex);
throw;
}
TearDown();
return(task.RunId);
}
public void ImportStartTwoImportersFailureTest()
{
lock (TrioWing)
{
IBatchConnector <CoordinatedData> emailConnector1;
IBatchConnector <CoordinatedData> emailConnector2;
Task <IBatchConnector <CoordinatedData> > task = null;
try
{
var kernel = BatchProcessorFactory.GetKernel <CoordinatedData>();
emailConnector1 = kernel.GetConnector("EmailImporter");
task = emailConnector1.ExecuteConnector(ExecutionTypes.Full);
emailConnector2 = kernel.GetConnector("EmailImporter");
var task1 = emailConnector2.ExecuteConnector(ExecutionTypes.Full);
Task.WaitAll(task, task1);
Assert.Fail("Should throw InvalidAsynchronousStateException");
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(InvalidAsynchronousStateException));
}
}
}
private static IBatchProgressLogger GetLogger()
{
return(BatchProcessorFactory.GetKernel <T>().GetLogger());
}
