public override void LoadEntity(ContainerBuilder builder, Process process, Entity entity) {
if (entity.Delete) {
builder.Register<IEntityDeleteHandler>(ctx => {
var context = new PipelineContext(ctx.Resolve<IPipelineLogger>(), process, entity);
var inputConnection = process.Connections.First(c => c.Name == entity.Connection);
IRead input = new NullReader(context);
switch (inputConnection.Provider) {
case "sqlserver":
input = new SqlReader(context, entity.GetPrimaryKey(), ReadFrom.Input);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = process.Connections.First(c => c.Name == "output");
switch (outputConnection.Provider) {
case "sqlserver":
output = new SqlReader(context, entity.GetPrimaryKey(), ReadFrom.Output);
deleter = new SqlDeleter(new OutputContext(context, new Incrementer(context)));
break;
}
return new ParallelDeleteHandler(new DefaultDeleteHandler(entity, input, output, deleter));
}).Named<IEntityDeleteHandler>(entity.Key);
}
}
public override void LoadEntity(ContainerBuilder builder, Process process, Entity entity)
{
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => {
var context = new PipelineContext(ctx.Resolve <IPipelineLogger>(), process, entity);
var inputConnection = process.Connections.First(c => c.Name == entity.Connection);
IRead input = new NullReader(context);
switch (inputConnection.Provider)
{
case "sqlserver":
input = new SqlReader(context, entity.GetPrimaryKey(), ReadFrom.Input);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = process.Connections.First(c => c.Name == "output");
switch (outputConnection.Provider)
{
case "sqlserver":
output = new SqlReader(context, entity.GetPrimaryKey(), ReadFrom.Output);
deleter = new SqlDeleter(new OutputContext(context, new Incrementer(context)));
break;
}
return(new ParallelDeleteHandler(new DefaultDeleteHandler(entity, input, output, deleter)));
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
/// <summary>Clone existing repository.</summary>
/// <param name="parameters"><see cref="CloneRepositoryParameters"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="parameters"/> == <c>null</c>.</exception>
public Task InvokeAsync(CloneRepositoryParameters parameters, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
Verify.Argument.IsNotNull(parameters, nameof(parameters));
var command = _commandFactory(parameters, true);
if (!Directory.Exists(parameters.Path))
{
Directory.CreateDirectory(parameters.Path);
}
progress?.Report(new OperationProgress(Resources.StrsConnectingToRemoteHost.AddEllipsis()));
var errorMessages = default(List <string>);
var stdOutReceiver = new NullReader();
var stdErrReceiver = new NotifyingAsyncTextReader();
stdErrReceiver.TextLineReceived += (s, e) =>
{
if (!string.IsNullOrWhiteSpace(e.Text))
{
var parser = new GitParser(e.Text);
var operationProgress = parser.ParseProgress();
progress?.Report(operationProgress);
if (operationProgress.IsIndeterminate)
{
if (!string.IsNullOrWhiteSpace(operationProgress.ActionName))
{
if (errorMessages == null)
{
errorMessages = new List <string>();
}
errorMessages.Add(operationProgress.ActionName);
}
}
else
{
errorMessages?.Clear();
}
}
};
return(_commandExecutor
.ExecuteCommandAsync(command, stdOutReceiver, stdErrReceiver, CommandExecutionFlags.None, cancellationToken)
.ContinueWith(
t =>
{
var exitCode = TaskUtility.UnwrapResult(t);
if (exitCode != 0)
{
var errorMessage = errorMessages != null && errorMessages.Count != 0
? string.Join(Environment.NewLine, errorMessages)
: string.Format(CultureInfo.InvariantCulture, "git process exited with code {0}", exitCode);
throw new GitException(errorMessage);
}
},
cancellationToken,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default));
}
public async Task InvokeAsync(TParameters parameters, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
Verify.Argument.IsNotNull(parameters, nameof(parameters));
progress?.Report(new OperationProgress(Resources.StrsConnectingToRemoteHost.AddEllipsis()));
var errorMessages = default(List <string>);
var stdOutReceiver = new NullReader();
var stdErrReceiver = new NotifyingAsyncTextReader();
stdErrReceiver.TextLineReceived += (s, e) =>
{
if (!string.IsNullOrWhiteSpace(e.Text))
{
var parser = new GitParser(e.Text);
var operationProgress = parser.ParseProgress();
progress?.Report(operationProgress);
if (operationProgress.IsIndeterminate)
{
if (errorMessages == null)
{
errorMessages = new List <string>();
}
errorMessages.Add(operationProgress.ActionName);
}
else
{
errorMessages?.Clear();
}
}
};
var command = _commandFactory(parameters, true);
var processExitCode = await _commandExecutor
.ExecuteCommandAsync(
command,
stdOutReceiver,
stdErrReceiver,
CommandExecutionFlags.None,
cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
if (processExitCode != 0)
{
var errorMessage = errorMessages != null && errorMessages.Count != 0
? string.Join(Environment.NewLine, errorMessages)
: string.Format(CultureInfo.InvariantCulture, "git process exited with code {0}", processExitCode);
throw new GitException(errorMessage);
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// connections
foreach (var connection in _process.Connections.Where(c => _ado.Contains(c.Provider)))
{
var cn = connection;
// Connection Factory
builder.Register <IConnectionFactory>(ctx => {
switch (cn.Provider)
{
case "sqlserver":
return(new SqlServerConnectionFactory(cn));
case "mysql":
return(new MySqlConnectionFactory(cn));
default:
return(new NullConnectionFactory());
}
}).Named <IConnectionFactory>(connection.Key).InstancePerLifetimeScope();
// Schema Reader
builder.Register <ISchemaReader>(ctx => {
var factory = ctx.ResolveNamed <IConnectionFactory>(cn.Key);
return(new AdoSchemaReader(ctx.ResolveNamed <IConnectionContext>(cn.Key), factory));
}).Named <ISchemaReader>(connection.Key);
}
//ISchemaReader
//IOutputController
//IRead (Process for Calculated Columns)
//IWrite (Process for Calculated Columns)
//IInitializer (Process)
// Per Entity
// IInputVersionDetector
// IRead (Input, per Entity)
// IOutputController
// -- IBatchReader (for matching)
// -- IWriteMasterUpdateQuery (for updating)
// IUpdate
// IWrite
// IEntityDeleteHandler
// entitiy input
foreach (var entity in _process.Entities.Where(e => _ado.Contains(_process.Connections.First(c => c.Name == e.Connection).Provider)))
{
// INPUT READER
builder.Register(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
IRead dataReader;
switch (input.Connection.Provider)
{
case "mysql":
case "sqlserver":
dataReader = new AdoInputReader(
input,
input.InputFields,
ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key),
rowFactory
);
break;
default:
dataReader = new NullReader(input, false);
break;
}
// "form" mode support if filter on primary key exists
if (_process.Mode == "form" && entity.GetPrimaryKey().Any() && entity.GetPrimaryKey().All(f => entity.Filter.Any(i => i.Field == f.Alias || i.Field == f.Name)))
{
if (entity.GetPrimaryKey().All(pk => entity.Filter.First(i => i.Field == pk.Alias || i.Field == pk.Name).Value == (pk.Default == Constants.DefaultSetting ? Constants.StringDefaults()[pk.Type] : pk.Default)))
{
// primary key is default, don't read from database
return(new ParameterRowReader(input, new DefaultRowReader(input, rowFactory)));
}
// read from database and update with parameters, otherwise just return the data reader
if (HttpContext.Current.Request.HttpMethod == "POST")
{
return(new ParameterRowReader(input, dataReader, rowFactory));
}
}
return(dataReader);
}).Named <IRead>(entity.Key);
// INPUT VERSION DETECTOR
builder.Register <IInputProvider>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "mysql":
case "sqlserver":
return(new AdoInputProvider(input, ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key)));
default:
return(new NullInputProvider());
}
}).Named <IInputProvider>(entity.Key);
}
// entity output
if (_ado.Contains(_process.Output().Provider))
{
var calc = _process.ToCalculatedFieldsProcess();
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.Resolve <OutputContext>();
if (_process.Mode != "init")
{
return(new NullOutputController());
}
switch (output.Connection.Provider)
{
case "mysql":
case "sqlserver":
var actions = new List <IAction> {
new AdoStarViewCreator(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))
};
if (_process.Flatten)
{
actions.Add(new AdoFlatTableCreator(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
}
return(new AdoStarController(output, actions));
default:
return(new NullOutputController());
}
}).As <IOutputController>();
// PROCESS CALCULATED READER
builder.Register <IRead>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext);
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
var capacity = outputContext.Entity.Fields.Count + outputContext.Entity.CalculatedFields.Count;
var rowFactory = new RowFactory(capacity, false, false);
return(new AdoStarParametersReader(outputContext, _process, cf, rowFactory));
}).As <IRead>();
// PROCESS CALCULATED FIELD WRITER
builder.Register <IWrite>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext);
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
return(new AdoCalculatedFieldUpdater(outputContext, _process, cf));
}).As <IWrite>();
// PROCESS INITIALIZER
builder.Register <IInitializer>(ctx => {
var output = ctx.Resolve <OutputContext>();
return(new AdoInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
}).As <IInitializer>();
// ENTITIES
foreach (var e in _process.Entities)
{
var entity = e;
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "sqlserver":
return(new SqlServerWriter(
output,
cf,
ctx.ResolveNamed <IBatchReader>(entity.Key),
new AdoEntityUpdater(output, cf)
));
case "mysql":
return(new AdoEntityWriter(
output,
ctx.ResolveNamed <IBatchReader>(entity.Key),
new AdoEntityInserter(output, cf),
entity.Update ? (IWrite) new AdoEntityUpdater(output, cf) : new NullWriter(output)
));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
builder.Register <IOutputProvider>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
return(new AdoOutputProvider(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key), ctx.ResolveNamed <IWrite>(entity.Key)));
}).Named <IOutputProvider>(entity.Key);
// ENTITY OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "sqlserver":
var initializer = _process.Mode == "init" ? (IAction) new AdoEntityInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)) : new NullInitializer();
return(new AdoOutputController(
output,
initializer,
ctx.ResolveNamed <IInputProvider>(entity.Key),
ctx.ResolveNamed <IOutputProvider>(entity.Key),
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// OUTPUT ROW MATCHER
builder.Register <IBatchReader>(ctx => {
if (!entity.Update)
{
return(new NullBatchReader());
}
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", output.GetAllEntityFields().Count()));
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
return(new AdoEntityMatchingKeysReader(output, cf, rowFactory));
}).Named <IBatchReader>(entity.Key);
// MASTER UPDATE QUERY
builder.Register <IWriteMasterUpdateQuery>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var factory = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "mysql":
return(new MySqlUpdateMasterKeysQueryWriter(output, factory));
default:
return(new SqlServerUpdateMasterKeysQueryWriter(output, factory));
}
}).Named <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys");
// MASTER UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlserver":
return(new AdoMasterUpdater(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys")
));
case "sqlite":
case "sqlce":
return(new AdoTwoPartMasterUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
default:
return(new NullMasterUpdater());
}
}).Named <IUpdate>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => new NullDeleteHandler()).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// Connections
foreach (var c in _process.Connections.Where(cn => cn.Provider == "lucene"))
{
switch (c.Provider)
{
case "lucene":
// Analyzers
builder.Register <Analyzer>(ctx => new KeywordAnalyzer()).Named <Analyzer>(DefaultAnalyzer);
foreach (var analyzer in _process.SearchTypes.Where(st => st.Analyzer != string.Empty && st.Analyzer != DefaultAnalyzer).Select(st => st.Analyzer).Distinct())
{
switch (analyzer)
{
case "simple":
builder.Register <Analyzer>(ctx => new SimpleAnalyzer()).Named <Analyzer>(analyzer);
break;
case "whitespace":
builder.Register <Analyzer>(ctx => new WhitespaceAnalyzer()).Named <Analyzer>(analyzer);
break;
case "standard":
builder.Register <Analyzer>(ctx => new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30)).Named <Analyzer>(analyzer);
break;
default:
builder.Register <Analyzer>(ctx => new KeywordAnalyzer()).Named <Analyzer>(analyzer);
break;
}
}
// entity index writers
foreach (var e in _process.Entities)
{
// Directory
builder.Register(ctx => new DirectoryFactory(Path.Combine(c.Folder, e.Alias))).Named <DirectoryFactory>(e.Key);
// Per Field Analyzer
builder.Register <Analyzer>(ctx => {
var analyzers = new PerFieldAnalyzerWrapper(ctx.ResolveNamed <Analyzer>(DefaultAnalyzer));
var context = ctx.ResolveNamed <OutputContext>(e.Key);
foreach (var field in new FieldSearchTypes(context.Process, context.OutputFields))
{
if (field.SearchType.Name != "none")
{
analyzers.AddAnalyzer(field.Alias, ctx.ResolveNamed <Analyzer>(field.SearchType.Analyzer == string.Empty ? DefaultAnalyzer : field.SearchType.Analyzer));
}
}
return(analyzers);
}).Named <Analyzer>(e.Key + ReadFrom.Output);
builder.Register <Analyzer>(ctx => {
var analyzers = new PerFieldAnalyzerWrapper(ctx.ResolveNamed <Analyzer>(DefaultAnalyzer));
var context = ctx.ResolveNamed <InputContext>(e.Key);
foreach (var field in new FieldSearchTypes(context.Process, context.InputFields))
{
if (field.SearchType.Name != "none")
{
analyzers.AddAnalyzer(field.Field.Name, ctx.ResolveNamed <Analyzer>(field.SearchType.Analyzer == string.Empty ? DefaultAnalyzer : field.SearchType.Analyzer));
}
}
return(analyzers);
}).Named <Analyzer>(e.Key + ReadFrom.Input);
// Index Writer Factory
builder.Register(ctx => new IndexWriterFactory(ctx.ResolveNamed <DirectoryFactory>(e.Key), ctx.ResolveNamed <Analyzer>(e.Key + ReadFrom.Output))).Named <IndexWriterFactory>(e.Key);
// Index Reader Factory
builder.Register(ctx => new IndexReaderFactory(ctx.ResolveNamed <DirectoryFactory>(e.Key), ctx.ResolveNamed <IndexWriterFactory>(e.Key))).Named <IndexReaderFactory>(e.Key);
// Index Searcher Factory
builder.Register(ctx => new SearcherFactory(ctx.ResolveNamed <IndexReaderFactory>(e.Key))).Named <SearcherFactory>(e.Key);
}
break;
}
}
// entity input
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Connection).Provider == "lucene"))
{
// INPUT VERSION DETECTOR
builder.Register <IInputVersionDetector>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "lucene":
return(new LuceneInputVersionDetector(input, ctx.ResolveNamed <SearcherFactory>(entity.Key)));
default:
return(new NullVersionDetector());
}
}).Named <IInputVersionDetector>(entity.Key);
// INPUT READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
switch (input.Connection.Provider)
{
case "lucene":
return(new LuceneReader(input, input.InputFields, ctx.ResolveNamed <SearcherFactory>(entity.Key), ctx.ResolveNamed <Analyzer>(entity.Key + ReadFrom.Input), ctx.ResolveNamed <IndexReaderFactory>(entity.Key), rowFactory, ReadFrom.Input));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
}
// entity output
if (_process.Output().Provider == "lucene")
{
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
// PROCESS INITIALIZER
builder.Register <IInitializer>(ctx => {
var output = ctx.Resolve <OutputContext>();
return(new LuceneInitializer(output));
}).As <IInitializer>();
foreach (var entity in _process.Entities)
{
// UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
output.Warn($"{output.Connection.Provider} does not denormalize.");
return(new NullMasterUpdater());
}).Named <IUpdate>(entity.Key);
// OUTPUT
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "lucene":
return(new LuceneOutputController(
output,
new NullInitializer(),
ctx.ResolveNamed <IInputVersionDetector>(entity.Key),
new LuceneOutputVersionDetector(output, ctx.ResolveNamed <SearcherFactory>(entity.Key)),
ctx.ResolveNamed <SearcherFactory>(entity.Key),
ctx.ResolveNamed <IndexReaderFactory>(entity.Key)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "lucene":
return(new LuceneWriter(output, ctx.ResolveNamed <IndexWriterFactory>(entity.Key), ctx.ResolveNamed <SearcherFactory>(entity.Key)));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => {
var context = ctx.ResolveNamed <IContext>(entity.Key);
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", inputContext.RowCapacity));
IRead input = new NullReader(context);
var primaryKey = entity.GetPrimaryKey();
switch (inputContext.Connection.Provider)
{
case "lucene":
input = new LuceneReader(
inputContext,
primaryKey,
ctx.ResolveNamed <SearcherFactory>(entity.Key),
ctx.ResolveNamed <Analyzer>(entity.Key + ReadFrom.Input),
ctx.ResolveNamed <IndexReaderFactory>(entity.Key),
rowFactory,
ReadFrom.Input);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = _process.Output();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (outputConnection.Provider)
{
case "lucene":
output = new LuceneReader(
outputContext,
primaryKey,
ctx.ResolveNamed <SearcherFactory>(entity.Key),
ctx.ResolveNamed <Analyzer>(entity.Key + ReadFrom.Output),
ctx.ResolveNamed <IndexReaderFactory>(entity.Key),
rowFactory,
ReadFrom.Output
);
//TODO: need LuceneUpdater (update TflDeleted to true)
break;
}
var handler = new DefaultDeleteHandler(context, input, output, deleter);
// since the primary keys from the input may have been transformed into the output, you have to transform before comparing
// feels a lot like entity pipeline on just the primary keys... may look at consolidating
handler.Register(new DefaultTransform(context, entity.GetPrimaryKey().ToArray()));
handler.Register(TransformFactory.GetTransforms(ctx, _process, entity, primaryKey));
handler.Register(new StringTruncateTransfom(context, primaryKey));
return(new ParallelDeleteHandler(handler));
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
//CONNECTIONS
foreach (var connection in _process.Connections.Where(c => c.Provider.In("elasticsearch")))
{
connection.Url = connection.BuildElasticUrl();
builder.Register <IConnectionPool>(ctx => new SingleNodeConnectionPool(new Uri(connection.Url))).Named <IConnectionPool>(connection.Key);
// Elasticsearch.Net
builder.Register(ctx => {
var settings = new ConnectionConfiguration(ctx.ResolveNamed <IConnectionPool>(connection.Key));
if (_process.Mode != "init" && connection.RequestTimeout >= 0)
{
settings.RequestTimeout(new TimeSpan(0, 0, 0, connection.RequestTimeout * 1000));
}
if (connection.Timeout > 0)
{
settings.PingTimeout(new TimeSpan(0, 0, connection.Timeout));
}
return(new ElasticLowLevelClient(settings));
}).Named <IElasticLowLevelClient>(connection.Key);
// Process-Level Schema Reader
builder.Register <ISchemaReader>(ctx => new ElasticSchemaReader(ctx.ResolveNamed <IConnectionContext>(connection.Key), ctx.ResolveNamed <IElasticLowLevelClient>(connection.Key))).Named <ISchemaReader>(connection.Key);
// Entity Level Schema Readers
foreach (var entity in _process.Entities.Where(e => e.Connection == connection.Name))
{
builder.Register <ISchemaReader>(ctx => new ElasticSchemaReader(ctx.ResolveNamed <IConnectionContext>(entity.Key), ctx.ResolveNamed <IElasticLowLevelClient>(connection.Key))).Named <ISchemaReader>(entity.Key);
}
}
// Entity Input
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Connection).Provider == "elasticsearch"))
{
builder.Register <IInputVersionDetector>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "elasticsearch":
return(new ElasticInputVersionDetector(input, ctx.ResolveNamed <IElasticLowLevelClient>(input.Connection.Key)));
default:
return(new NullVersionDetector());
}
}).Named <IInputVersionDetector>(entity.Key);
// INPUT READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
switch (input.Connection.Provider)
{
case "elasticsearch":
return(new ElasticReader(input, input.InputFields, ctx.ResolveNamed <IElasticLowLevelClient>(input.Connection.Key), rowFactory, ReadFrom.Input));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
}
// Entity Output
if (_process.Output().Provider == "elasticsearch")
{
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
// PROCESS INITIALIZER
builder.Register <IInitializer>(ctx => {
var output = ctx.Resolve <OutputContext>();
return(new ElasticInitializer(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)));
}).As <IInitializer>();
foreach (var entity in _process.Entities)
{
// UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
output.Warn($"{output.Connection.Provider} does not denormalize.");
return(new NullMasterUpdater());
}).Named <IUpdate>(entity.Key);
// OUTPUT
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "elasticsearch":
var initializer = _process.Mode == "init" ? (IAction) new ElasticEntityInitializer(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)) : new NullInitializer();
return(new ElasticOutputController(
output,
initializer,
ctx.ResolveNamed <IInputVersionDetector>(entity.Key),
new ElasticOutputVersionDetector(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)),
ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "elasticsearch":
return(new ElasticWriter(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => {
var context = ctx.ResolveNamed <IContext>(entity.Key);
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", inputContext.RowCapacity));
IRead input = new NullReader(context);
var primaryKey = entity.GetPrimaryKey();
switch (inputContext.Connection.Provider)
{
case "elasticsearch":
input = new ElasticReader(
inputContext,
primaryKey,
ctx.ResolveNamed <IElasticLowLevelClient>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Input
);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = _process.Output();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (outputConnection.Provider)
{
case "elasticsearch":
output = new ElasticReader(
outputContext,
primaryKey,
ctx.ResolveNamed <IElasticLowLevelClient>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Output
);
deleter = new ElasticPartialUpdater(
outputContext,
new[] { context.Entity.TflDeleted() },
ctx.ResolveNamed <IElasticLowLevelClient>(inputContext.Connection.Key)
);
break;
}
var handler = new DefaultDeleteHandler(context, input, output, deleter);
// since the primary keys from the input may have been transformed into the output, you have to transform before comparing
// feels a lot like entity pipeline on just the primary keys... may look at consolidating
handler.Register(new DefaultTransform(context, entity.GetPrimaryKey().ToArray()));
handler.Register(TransformFactory.GetTransforms(ctx, _process, entity, primaryKey));
handler.Register(new StringTruncateTransfom(context, primaryKey));
return(new ParallelDeleteHandler(handler));
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
public void Build()
{
//MAPS
foreach (var map in _process.Maps.Where(m => m.Connection != string.Empty && m.Query != string.Empty))
{
var connection = _process.Connections.First(c => c.Name == map.Connection);
if (connection != null && connection.Provider == "elasticsearch")
{
_builder.Register <IMapReader>(ctx => new DefaultMapReader()).Named <IMapReader>(map.Name);
}
}
//CONNECTIONS
foreach (var connection in _process.Connections.Where(c => c.Provider == "elasticsearch"))
{
if (connection.Servers.Any(s => s.Url != "None"))
{
var uris = new List <Uri>();
foreach (var server in connection.Servers.Where(s => s.Url != "None"))
{
server.Url = server.GetElasticUrl();
uris.Add(new Uri(server.Url));
}
// for now, just use static connection pool, there are 2 other types...
_builder.Register <IConnectionPool>(ctx => new StaticConnectionPool(uris)).Named <IConnectionPool>(connection.Key);
}
else
{
connection.Url = connection.GetElasticUrl();
_builder.Register <IConnectionPool>(ctx => new SingleNodeConnectionPool(new Uri(connection.Url))).Named <IConnectionPool>(connection.Key);
}
// Elasticsearch.Net
_builder.Register(ctx => {
var settings = new ConnectionConfiguration(ctx.ResolveNamed <IConnectionPool>(connection.Key));
if (!string.IsNullOrEmpty(connection.User))
{
settings.BasicAuthentication(connection.User, connection.Password);
}
if (_process.Mode != "init" && connection.RequestTimeout >= 0)
{
settings.RequestTimeout(new TimeSpan(0, 0, 0, connection.RequestTimeout * 1000));
}
if (connection.Timeout > 0)
{
settings.PingTimeout(new TimeSpan(0, 0, connection.Timeout));
}
return(new ElasticLowLevelClient(settings));
}).Named <IElasticLowLevelClient>(connection.Key);
// Process-Level Schema Reader
_builder.Register <ISchemaReader>(ctx => new ElasticSchemaReader(ctx.ResolveNamed <IConnectionContext>(connection.Key), ctx.ResolveNamed <IElasticLowLevelClient>(connection.Key))).Named <ISchemaReader>(connection.Key);
// Entity Level Schema Readers
foreach (var entity in _process.Entities.Where(e => e.Input == connection.Name))
{
_builder.Register <ISchemaReader>(ctx => new ElasticSchemaReader(ctx.ResolveNamed <IConnectionContext>(entity.Key), ctx.ResolveNamed <IElasticLowLevelClient>(connection.Key))).Named <ISchemaReader>(entity.Key);
}
}
// Entity Input
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Input).Provider == "elasticsearch"))
{
_builder.Register <IInputProvider>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
return(new ElasticInputProvider(input, ctx.ResolveNamed <IElasticLowLevelClient>(input.Connection.Key)));
}).Named <IInputProvider>(entity.Key);
// INPUT READER
_builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
if (entity.Query == string.Empty)
{
return(new ElasticReader(input, input.InputFields, ctx.ResolveNamed <IElasticLowLevelClient>(input.Connection.Key), rowFactory, ReadFrom.Input));
}
return(new ElasticQueryReader(input, ctx.ResolveNamed <IElasticLowLevelClient>(input.Connection.Key), rowFactory));
}).Named <IRead>(entity.Key);
}
// Entity Output
if (_process.GetOutputConnection().Provider == "elasticsearch")
{
// PROCESS OUTPUT CONTROLLER
_builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
// PROCESS INITIALIZER
_builder.Register <IInitializer>(ctx => {
var output = ctx.Resolve <OutputContext>();
return(new ElasticInitializer(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)));
}).As <IInitializer>();
foreach (var entity in _process.Entities)
{
// UPDATER
_builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
output.Debug(() => $"{output.Connection.Provider} does not denormalize.");
return(new NullMasterUpdater());
}).Named <IUpdate>(entity.Key);
// OUTPUT
_builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "elasticsearch":
var initializer = _process.Mode == "init" ? (IAction) new ElasticEntityInitializer(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)) : new NullInitializer();
return(new ElasticOutputController(
output,
initializer,
ctx.ResolveNamed <IInputProvider>(entity.Key),
new ElasticOutputProvider(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)),
ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// WRITER
_builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "elasticsearch":
return(new ElasticWriter(output, ctx.ResolveNamed <IElasticLowLevelClient>(output.Connection.Key)));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
_builder.Register <IEntityDeleteHandler>(ctx => {
var context = ctx.ResolveNamed <IContext>(entity.Key);
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", inputContext.RowCapacity));
IRead input = new NullReader(context);
var primaryKey = entity.GetPrimaryKey();
switch (inputContext.Connection.Provider)
{
case "elasticsearch":
input = new ElasticReader(
inputContext,
primaryKey,
ctx.ResolveNamed <IElasticLowLevelClient>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Input
);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = _process.GetOutputConnection();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (outputConnection.Provider)
{
case "elasticsearch":
output = new ElasticReader(
outputContext,
primaryKey,
ctx.ResolveNamed <IElasticLowLevelClient>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Output
);
deleter = new ElasticPartialUpdater(
outputContext,
new[] { context.Entity.TflDeleted() },
ctx.ResolveNamed <IElasticLowLevelClient>(inputContext.Connection.Key)
);
break;
}
var handler = new DefaultDeleteHandler(context, input, output, deleter);
// since the primary keys from the input may have been transformed into the output, you have to transform before comparing
// feels a lot like entity pipeline on just the primary keys... may look at consolidating
handler.Register(new DefaultTransform(context, entity.GetPrimaryKey().ToArray()));
handler.Register(TransformFactory.GetTransforms(ctx, context, primaryKey));
handler.Register(new StringTruncateTransfom(context, primaryKey));
return(handler);
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// connections
foreach (var connection in _process.Connections.Where(c => c.Provider.In(_ado)))
{
// Connection Factory
builder.Register <IConnectionFactory>(ctx => {
switch (connection.Provider)
{
case "sqlserver":
return(new SqlServerConnectionFactory(connection));
case "mysql":
return(new MySqlConnectionFactory(connection));
case "postgresql":
return(new PostgreSqlConnectionFactory(connection));
case "sqlite":
return(new SqLiteConnectionFactory(connection));
default:
return(new NullConnectionFactory());
}
}).Named <IConnectionFactory>(connection.Key).InstancePerLifetimeScope();
// Schema Reader
builder.Register <ISchemaReader>(ctx => {
var factory = ctx.ResolveNamed <IConnectionFactory>(connection.Key);
return(new AdoSchemaReader(ctx.ResolveNamed <IConnectionContext>(connection.Key), factory));
}).Named <ISchemaReader>(connection.Key);
}
//ISchemaReader
//IOutputController
//IRead (Process for Calculated Columns)
//IWrite (Process for Calculated Columns)
//IInitializer (Process)
// Per Entity
// IInputVersionDetector
// IRead (Input, per Entity)
// IOutputController
// -- ITakeAndReturnRows (for matching)
// -- IWriteMasterUpdateQuery (for updating)
// IUpdate
// IWrite
// IEntityDeleteHandler
// entitiy input
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Connection).Provider.In(_ado)))
{
// INPUT READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
switch (input.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoInputReader(
input,
input.InputFields,
ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key),
rowFactory
));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
// INPUT VERSION DETECTOR
builder.Register <IInputVersionDetector>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoInputVersionDetector(input, ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key)));
default:
return(new NullVersionDetector());
}
}).Named <IInputVersionDetector>(entity.Key);
}
// entity output
if (_process.Output().Provider.In(_ado))
{
var calc = _process.ToCalculatedFieldsProcess();
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.Resolve <OutputContext>();
if (_process.Mode != "init")
{
return(new NullOutputController());
}
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoStarController(output, new AdoStarViewCreator(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))));
default:
return(new NullOutputController());
}
}).As <IOutputController>();
// PROCESS CALCULATED READER
builder.Register <IRead>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext, new Incrementer(calcContext));
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
var capacity = outputContext.Entity.Fields.Count + outputContext.Entity.CalculatedFields.Count;
var rowFactory = new RowFactory(capacity, false, false);
return(new AdoStarParametersReader(outputContext, _process, cf, rowFactory));
}).As <IRead>();
// PROCESS CALCULATED FIELD WRITER
builder.Register <IWrite>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext, new Incrementer(calcContext));
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
return(new AdoCalculatedFieldUpdater(outputContext, _process, cf));
}).As <IWrite>();
// PROCESS INITIALIZER
builder.Register <IInitializer>(ctx => {
var output = ctx.Resolve <OutputContext>();
return(new AdoInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
}).As <IInitializer>();
// ENTITIES
foreach (var entity in _process.Entities)
{
// ENTITY OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
var initializer = _process.Mode == "init" ? (IAction) new AdoEntityInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)) : new NullInitializer();
return(new AdoOutputController(
output,
initializer,
ctx.ResolveNamed <IInputVersionDetector>(entity.Key),
new AdoOutputVersionDetector(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)),
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// OUTPUT ROW MATCHER
builder.Register(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", output.GetAllEntityFields().Count()));
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "sqlite":
return(new TypedEntityMatchingKeysReader(new AdoEntityMatchingKeysReader(output, cf, rowFactory), output));
default:
return((ITakeAndReturnRows) new AdoEntityMatchingKeysReader(output, cf, rowFactory));
}
}).Named <ITakeAndReturnRows>(entity.Key);
// MASTER UPDATE QUERY
builder.Register <IWriteMasterUpdateQuery>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var factory = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "mysql":
return(new MySqlUpdateMasterKeysQueryWriter(output, factory));
case "postgresql":
return(new PostgreSqlUpdateMasterKeysQueryWriter(output, factory));
default:
return(new SqlServerUpdateMasterKeysQueryWriter(output, factory));
}
}).Named <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys");
// UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlserver":
return(new AdoMasterUpdater(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys")
));
case "sqlite":
return(new AdoTwoPartMasterUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
default:
return(new NullMasterUpdater());
}
}).Named <IUpdate>(entity.Key);
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "sqlserver":
return(new SqlServerWriter(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <ITakeAndReturnRows>(entity.Key),
new AdoEntityUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))
));
case "mysql":
case "postgresql":
case "sqlite":
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
return(new AdoEntityWriter(
output,
ctx.ResolveNamed <ITakeAndReturnRows>(entity.Key),
new AdoEntityInserter(output, cf),
new AdoEntityUpdater(output, cf)
));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => {
var context = ctx.ResolveNamed <IContext>(entity.Key);
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowCapacity = inputContext.Entity.GetPrimaryKey().Count();
var rowFactory = new RowFactory(rowCapacity, false, true);
IRead input = new NullReader(context);
var primaryKey = entity.GetPrimaryKey();
switch (inputContext.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
input = new AdoReader(
inputContext,
primaryKey,
ctx.ResolveNamed <IConnectionFactory>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Input
);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = _process.Output();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (outputConnection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
var ocf = ctx.ResolveNamed <IConnectionFactory>(outputConnection.Key);
output = new AdoReader(context, entity.GetPrimaryKey(), ocf, rowFactory, ReadFrom.Output);
deleter = new AdoDeleter(outputContext, ocf);
break;
}
var handler = new DefaultDeleteHandler(context, input, output, deleter);
// since the primary keys from the input may have been transformed into the output, you have to transform before comparing
// feels a lot like entity pipeline on just the primary keys... may look at consolidating
handler.Register(new DefaultTransform(context, entity.GetPrimaryKey().ToArray()));
handler.Register(TransformFactory.GetTransforms(ctx, _process, entity, primaryKey));
handler.Register(new StringTruncateTransfom(context, primaryKey));
return(new ParallelDeleteHandler(handler));
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
public void Test_NullReader()
{
const string raw = "null";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw));
var reader = new NullReader(stream, null);
var obj = reader.Read();
Assert.IsNotNull(obj);
stream.Dispose();
}
