public void GetRegistered()
{
var innerMapper = new MReadOnlyMappingManager();
innerMapper.getRegisteredTypes += () => new[] { typeof(TestDocument) };
var mapper = new MemoizingMappingManager(innerMapper);
var types = mapper.GetRegisteredTypes();
Assert.AreEqual(1, types.Count);
Assert.AreEqual(typeof(TestDocument), types.First());
mapper.GetRegisteredTypes();
}
public void GetRegistered()
{
var innerMapper = MockRepository.GenerateMock <IReadOnlyMappingManager>();
innerMapper.Expect(x => x.GetRegisteredTypes()).Repeat.Once().Return(new[] { typeof(TestDocument) });
var mapper = new MemoizingMappingManager(innerMapper);
var types = mapper.GetRegisteredTypes();
Assert.AreEqual(1, types.Count);
Assert.AreEqual(typeof(TestDocument), types.First());
types = mapper.GetRegisteredTypes();
innerMapper.VerifyAllExpectations();
}
public static void InitContainer()
{
ServiceLocator.SetLocatorProvider(() => Container);
Container.Clear();
var mapper = new MemoizingMappingManager(new AttributesMappingManager());
Container.Register <IReadOnlyMappingManager>(c => mapper);
var fieldSerializer = new DefaultFieldSerializer();
Container.Register <ISolrFieldSerializer>(c => fieldSerializer);
Container.Register <ISolrQuerySerializer>(c => new DefaultQuerySerializer(c.GetInstance <ISolrFieldSerializer>()));
Container.Register <ISolrFacetQuerySerializer>(c => new DefaultFacetQuerySerializer(c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrFieldSerializer>()));
}
public static ISolrBasicOperations <T> GetBasicServer <T>(ISolrConnection connection)
{
ISolrFieldParser fieldParser = new DefaultFieldParser();
IReadOnlyMappingManager mapper = new MemoizingMappingManager(new AttributesMappingManager());
ISolrDocumentPropertyVisitor visitor = new DefaultDocumentVisitor(mapper, fieldParser);
ISolrDocumentResponseParser <T> parser;
if (typeof(T) == typeof(Dictionary <string, object>))
{
parser = (ISolrDocumentResponseParser <T>) new SolrDictionaryDocumentResponseParser(fieldParser);
}
else
{
parser = new SolrDocumentResponseParser <T>(mapper, visitor, new SolrDocumentActivator <T>());
}
ISolrAbstractResponseParser <T> resultParser = new DefaultResponseParser <T>(parser);
ISolrFieldSerializer fieldSerializer = new DefaultFieldSerializer();
;
ISolrQuerySerializer querySerializer = new DefaultQuerySerializer(fieldSerializer);
ISolrFacetQuerySerializer facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, fieldSerializer);
// validate why only this?
ISolrMoreLikeThisHandlerQueryResultsParser <T> mlthResultParser = new SolrMoreLikeThisHandlerQueryResultsParser <T>(new[] { resultParser });
ISolrQueryExecuter <T> executor = new SolrQueryExecuter <T>(resultParser, connection, querySerializer, facetQuerySerializer, mlthResultParser);
ISolrDocumentSerializer <T> documentSerializer;
if (typeof(T) == typeof(Dictionary <string, object>))
{
documentSerializer = (ISolrDocumentSerializer <T>) new SolrDictionarySerializer(fieldSerializer);
}
else
{
documentSerializer = new SolrDocumentSerializer <T>(mapper, fieldSerializer);
}
ISolrSchemaParser schemaParser = new SolrSchemaParser();
ISolrHeaderResponseParser headerParser = new HeaderResponseParser <T>();
ISolrDIHStatusParser dihStatusParser = new SolrDIHStatusParser();
ISolrExtractResponseParser extractResponseParser = new ExtractResponseParser(headerParser);
ISolrBasicOperations <T> basicServer = new SolrBasicServer <T>(connection, executor, documentSerializer, schemaParser, headerParser, querySerializer, dihStatusParser, extractResponseParser);
return(basicServer);
}
public void GetUniqueKeyIsMemoized()
{
var innerMapper = new MReadOnlyMappingManager();
innerMapper.getUniqueKey += t => {
Assert.AreEqual(typeof(TestDocument), t);
return(new SolrFieldModel(property: typeof(TestDocument).GetProperty("Id"),
fieldName: "id"));
};
var mapper = new MemoizingMappingManager(innerMapper);
mapper.GetUniqueKey(typeof(TestDocument));
mapper.GetUniqueKey(typeof(TestDocument));
Assert.AreEqual(1, innerMapper.getUniqueKey.Calls);
}
public static void InitContainer()
{
ServiceLocator.SetLocatorProvider(() => Container);
Container.Clear();
var mapper = new MemoizingMappingManager(new AttributesMappingManager());
Container.Register <IReadOnlyMappingManager>(c => mapper);
var fieldParser = new DefaultFieldParser();
Container.Register <ISolrFieldParser>(c => fieldParser);
var fieldSerializer = new DefaultFieldSerializer();
Container.Register <ISolrFieldSerializer>(c => fieldSerializer);
Container.Register <ISolrQuerySerializer>(c => new DefaultQuerySerializer(c.GetInstance <ISolrFieldSerializer>()));
Container.Register <ISolrFacetQuerySerializer>(c => new DefaultFacetQuerySerializer(c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrFieldSerializer>()));
Container.Register <ISolrDocumentPropertyVisitor>(c => new DefaultDocumentVisitor(c.GetInstance <IReadOnlyMappingManager>(), c.GetInstance <ISolrFieldParser>()));
//var cache = new HttpRuntimeCache();
//Container.Register<ISolrCache>(c => cache);
var solrSchemaParser = new SolrSchemaParser();
Container.Register <ISolrSchemaParser>(c => solrSchemaParser);
var solrDIHStatusParser = new SolrDIHStatusParser();
Container.Register <ISolrDIHStatusParser>(c => solrDIHStatusParser);
var headerParser = new HeaderResponseParser <string>();
Container.Register <ISolrHeaderResponseParser>(c => headerParser);
var extractResponseParser = new ExtractResponseParser(headerParser);
Container.Register <ISolrExtractResponseParser>(c => extractResponseParser);
Container.Register <IValidationRule>(typeof(MappedPropertiesIsInSolrSchemaRule).FullName, c => new MappedPropertiesIsInSolrSchemaRule());
Container.Register <IValidationRule>(typeof(RequiredFieldsAreMappedRule).FullName, c => new RequiredFieldsAreMappedRule());
Container.Register <IValidationRule>(typeof(UniqueKeyMatchesMappingRule).FullName, c => new UniqueKeyMatchesMappingRule());
Container.Register <IValidationRule>(typeof(MultivaluedMappedToCollectionRule).FullName, c => new MultivaluedMappedToCollectionRule());
Container.Register <IMappingValidator>(c => new MappingValidator(c.GetInstance <IReadOnlyMappingManager>(), c.GetAllInstances <IValidationRule>().ToArray()));
Container.Register <ISolrStatusResponseParser>(c => new SolrStatusResponseParser());
}
public void CallsInnerJustOnce()
{
var innerMapper = new MReadOnlyMappingManager();
innerMapper.getFields += t => {
Assert.AreEqual(typeof(TestDocument), t);
return(new Dictionary <string, SolrFieldModel> {
{ "id", new SolrFieldModel(property: typeof(TestDocument).GetProperty("Id"), fieldName: "id") },
});
};
var mapper = new MemoizingMappingManager(innerMapper);
mapper.GetFields(typeof(TestDocument));
mapper.GetFields(typeof(TestDocument));
Assert.AreEqual(1, innerMapper.getFields.Calls);
}
public static ISolrOperations <T> GetServer <T>(ISolrConnection connection)
{
IReadOnlyMappingManager mapper = new MemoizingMappingManager(new AttributesMappingManager());
IReadOnlyMappingManager mappingManager = mapper;
IMappingValidator mappingValidator = new MappingValidator(mapper, new IValidationRule[] {
new MappedPropertiesIsInSolrSchemaRule(),
new RequiredFieldsAreMappedRule(),
new UniqueKeyMatchesMappingRule(),
new MultivaluedMappedToCollectionRule()
});
var basicServer = GetBasicServer <T>(connection);
ISolrOperations <T> server = new SolrServer <T>(basicServer, mappingManager, mappingValidator);
return(server);
}
public void GetUniqueKeyIsMemoized()
{
var mocks = new MockRepository();
var innerMapper = mocks.StrictMock <IReadOnlyMappingManager>();
With.Mocks(mocks)
.Expecting(() => Expect.Call(innerMapper.GetUniqueKey(typeof(TestDocument)))
.Repeat.Once()
.Return(new SolrFieldModel {
Property = typeof(TestDocument).GetProperty("Id"), FieldName = "id"
}))
.Verify(() => {
var mapper = new MemoizingMappingManager(innerMapper);
mapper.GetUniqueKey(typeof(TestDocument));
mapper.GetUniqueKey(typeof(TestDocument));
});
}
public void CallsInnerJustOnce()
{
var mocks = new MockRepository();
var innerMapper = mocks.StrictMock <IReadOnlyMappingManager>();
With.Mocks(mocks)
.Expecting(() => Expect.Call(innerMapper.GetFields(typeof(TestDocument)))
.Repeat.Once()
.Return(new Dictionary <string, SolrFieldModel> {
{ "id", new SolrFieldModel {
Property = typeof(TestDocument).GetProperty("Id"), FieldName = "id"
} },
}))
.Verify(() => {
var mapper = new MemoizingMappingManager(innerMapper);
mapper.GetFields(typeof(TestDocument));
mapper.GetFields(typeof(TestDocument));
});
}
public DefaultSolrLocator()
{
MappingManager = new MemoizingMappingManager(new AttributesMappingManager());
FieldParser = new DefaultFieldParser();
DocumentPropertyVisitor = new DefaultDocumentVisitor(MappingManager, FieldParser);
if (typeof(T) == typeof(Dictionary <string, object>))
{
DocumentResponseParser =
(ISolrDocumentResponseParser <T>) new SolrDictionaryDocumentResponseParser(FieldParser);
}
else
{
DocumentResponseParser = new SolrDocumentResponseParser <T>(MappingManager, DocumentPropertyVisitor,
new SolrDocumentActivator <T>());
}
ResponseParser = new DefaultResponseParser <T>(DocumentResponseParser);
SchemaParser = new SolrSchemaParser();
HeaderParser = new HeaderResponseParser <string>();
DihStatusParser = new SolrDIHStatusParser();
ExtractResponseParser = new ExtractResponseParser(HeaderParser);
FieldSerializer = new DefaultFieldSerializer();
QuerySerializer = new DefaultQuerySerializer(FieldSerializer);
FacetQuerySerializer = new DefaultFacetQuerySerializer(QuerySerializer, FieldSerializer);
MlthResultParser = new SolrMoreLikeThisHandlerQueryResultsParser <T>(new[] { ResponseParser });
StatusResponseParser = new SolrStatusResponseParser();
if (typeof(T) == typeof(Dictionary <string, object>))
{
DocumentSerializer = (ISolrDocumentSerializer <T>) new SolrDictionarySerializer(FieldSerializer);
}
else
{
DocumentSerializer = new SolrDocumentSerializer <T>(MappingManager, FieldSerializer);
}
HttpCache = new NullCache();
}
public override void Load()
{
Bind <AbstractConnectionDependencies>().To <InternalDependencies>().WhenInjectedInto <InternalConnection>();
Bind <AbstractConnection>().To <InternalConnection>().Named("internal");
Bind <ILogger>().ToConstant(_logger);
var providers = _process
.Connections
.Where(c => c.Provider != "internal")
.Select(c => c.Provider)
.Distinct();
foreach (var provider in providers)
{
switch (provider)
{
case "sqlserver":
Bind <AbstractConnectionDependencies>().To <SqlServerDependencies>().WhenInjectedInto <SqlServerConnection>();
Bind <AbstractConnection>().To <SqlServerConnection>().Named(provider);
break;
case "mysql":
Bind <AbstractConnectionDependencies>().To <MySqlDependencies>().WhenInjectedInto <MySqlConnection>();
Bind <AbstractConnection>().To <MySqlConnection>().Named(provider);
break;
case "postgresql":
Bind <AbstractConnectionDependencies>().To <PostgreSqlDependencies>().WhenInjectedInto <PostgreSqlConnection>();
Bind <AbstractConnection>().To <PostgreSqlConnection>().Named(provider);
break;
case "sqlce":
Bind <AbstractConnectionDependencies>().To <SqlCeDependencies>().WhenInjectedInto <SqlCeConnection>();
Bind <AbstractConnection>().To <SqlCeConnection>().Named(provider);
break;
case "analysisservices":
Bind <AbstractConnectionDependencies>().To <AnalysisServicesDependencies>().WhenInjectedInto <AnalysisServicesConnection>();
Bind <AbstractConnection>().To <AnalysisServicesConnection>().Named(provider);
break;
case "file":
Bind <AbstractConnectionDependencies>().To <FileDependencies>().WhenInjectedInto <FileConnection>();
Bind <AbstractConnection>().To <FileConnection>().Named(provider);
break;
case "folder":
Bind <AbstractConnectionDependencies>().To <FolderDependencies>().WhenInjectedInto <FolderConnection>();
Bind <AbstractConnection>().To <FolderConnection>().Named("folder");
break;
case "console":
Bind <AbstractConnectionDependencies>().To <ConsoleDependencies>().WhenInjectedInto <ConsoleConnection>();
Bind <AbstractConnection>().To <ConsoleConnection>().Named(provider);
break;
case "log":
Bind <AbstractConnectionDependencies>().To <LogDependencies>().WhenInjectedInto <LogConnection>();
Bind <AbstractConnection>().To <LogConnection>().Named(provider);
break;
case "mail":
Bind <AbstractConnectionDependencies>().To <MailDependencies>().WhenInjectedInto <MailConnection>();
Bind <AbstractConnection>().To <MailConnection>().Named(provider);
break;
case "html":
Bind <AbstractConnectionDependencies>().To <HtmlDependencies>().WhenInjectedInto <HtmlConnection>();
Bind <AbstractConnection>().To <HtmlConnection>().Named(provider);
break;
case "elasticsearch":
Bind <AbstractConnectionDependencies>().To <ElasticSearchDependencies>().WhenInjectedInto <ElasticSearchConnection>();
Bind <AbstractConnection>().To <ElasticSearchConnection>().Named(provider);
break;
case "solr":
Bind <AbstractConnectionDependencies>().To <SolrDependencies>().WhenInjectedInto <SolrConnection>();
Bind <AbstractConnection>().To <SolrConnection>().Named(provider);
//solrnet binding
var mapper = new MemoizingMappingManager(new AttributesMappingManager());
Bind <IReadOnlyMappingManager>().ToConstant(mapper);
if (HttpRuntime.AppDomainAppId != null)
{
Bind <ISolrCache>().To <HttpRuntimeCache>();
}
Bind <ISolrDocumentPropertyVisitor>().To <DefaultDocumentVisitor>();
Bind <ISolrFieldParser>().To <DefaultFieldParser>();
Bind(typeof(ISolrDocumentActivator <>)).To(typeof(SolrDocumentActivator <>));
Bind(typeof(ISolrDocumentResponseParser <>)).To(typeof(SolrDocumentResponseParser <>));
Bind <ISolrDocumentResponseParser <Dictionary <string, object> > >().To <SolrDictionaryDocumentResponseParser>();
Bind <ISolrFieldSerializer>().To <DefaultFieldSerializer>();
Bind <ISolrQuerySerializer>().To <DefaultQuerySerializer>();
Bind <ISolrFacetQuerySerializer>().To <DefaultFacetQuerySerializer>();
Bind(typeof(ISolrAbstractResponseParser <>)).To(typeof(DefaultResponseParser <>));
Bind <ISolrHeaderResponseParser>().To <HeaderResponseParser <string> >();
Bind <ISolrExtractResponseParser>().To <ExtractResponseParser>();
foreach (var p in new[] {
typeof(MappedPropertiesIsInSolrSchemaRule),
typeof(RequiredFieldsAreMappedRule),
typeof(UniqueKeyMatchesMappingRule),
typeof(MultivaluedMappedToCollectionRule),
})
{
Bind <IValidationRule>().To(p);
}
Bind(typeof(ISolrMoreLikeThisHandlerQueryResultsParser <>)).To(typeof(SolrMoreLikeThisHandlerQueryResultsParser <>));
Bind(typeof(ISolrDocumentSerializer <>)).To(typeof(SolrDocumentSerializer <>));
Bind(typeof(ISolrDocumentSerializer <Dictionary <string, object> >)).To(typeof(SolrDictionarySerializer));
Bind <ISolrSchemaParser>().To <SolrSchemaParser>();
Bind <ISolrDIHStatusParser>().To <SolrDIHStatusParser>();
Bind <IMappingValidator>().To <MappingValidator>();
Bind <ISolrStatusResponseParser>().To <SolrStatusResponseParser>();
Bind <ISolrCoreAdmin>().To <SolrCoreAdmin>();
// each entity-core must be bound
foreach (var entity in _process.Entities)
{
var connection = entity.Connection;
foreach (var cn in _process.Connections.Where(c => c.Name == connection && c.Provider == "solr"))
{
var coreUrl = cn.NormalizeUrl(8983) + "/" + (entity.PrependProcessNameToOutputName ? _process.Name + entity.Alias : entity.Alias);
_logger.EntityInfo(entity.Name, "Registering SOLR core {0}", coreUrl);
Bind <ISolrConnection>().ToConstant(new Libs.SolrNet.Impl.SolrConnection(coreUrl))
.WithMetadata(CORE_ID, coreUrl);
var iSolrQueryExecuter = typeof(ISolrQueryExecuter <>).MakeGenericType(_type);
var solrQueryExecuter = typeof(SolrQueryExecuter <>).MakeGenericType(_type);
Bind(iSolrQueryExecuter).To(solrQueryExecuter)
.Named(coreUrl + solrQueryExecuter)
.WithMetadata(CORE_ID, coreUrl)
.WithConstructorArgument("connection", ctx => ctx.Kernel.Get <ISolrConnection>(bindingMetaData => bindingMetaData.Has(CORE_ID) && bindingMetaData.Get <string>(CORE_ID).Equals(coreUrl)));
var solrBasicOperations = typeof(ISolrBasicOperations <>).MakeGenericType(_type);
var solrBasicReadOnlyOperations = typeof(ISolrBasicReadOnlyOperations <>).MakeGenericType(_type);
var solrBasicServer = typeof(SolrBasicServer <>).MakeGenericType(_type);
Bind(solrBasicOperations).To(solrBasicServer)
.Named(coreUrl + solrBasicServer)
.WithMetadata(CORE_ID, coreUrl)
.WithConstructorArgument("connection", ctx => ctx.Kernel.Get <ISolrConnection>(bindingMetaData => bindingMetaData.Has(CORE_ID) && bindingMetaData.Get <string>(CORE_ID).Equals(coreUrl)))
.WithConstructorArgument("queryExecuter", ctx => ctx.Kernel.Get(iSolrQueryExecuter, bindingMetaData => bindingMetaData.Has(CORE_ID) && bindingMetaData.Get <string>(CORE_ID).Equals(coreUrl)));
Bind(solrBasicReadOnlyOperations).To(solrBasicServer)
.Named(coreUrl + solrBasicServer)
.WithMetadata(CORE_ID, coreUrl)
.WithConstructorArgument("connection", ctx => ctx.Kernel.Get <ISolrConnection>(bindingMetaData => bindingMetaData.Has(CORE_ID) && bindingMetaData.Get <string>(CORE_ID).Equals(coreUrl)))
.WithConstructorArgument("queryExecuter", ctx => ctx.Kernel.Get(iSolrQueryExecuter, bindingMetaData => bindingMetaData.Has(CORE_ID) && bindingMetaData.Get <string>(CORE_ID).Equals(coreUrl)));
var solrOperations = typeof(ISolrOperations <>).MakeGenericType(_type);
var solrServer = typeof(SolrServer <>).MakeGenericType(_type);
var solrReadOnlyOperations = typeof(ISolrReadOnlyOperations <>).MakeGenericType(_type);
Bind(solrOperations).To(solrServer)
.Named(coreUrl)
.WithMetadata(CORE_ID, coreUrl)
.WithConstructorArgument("basicServer", ctx => ctx.Kernel.Get(solrBasicOperations, bindingMetaData => bindingMetaData.Has(CORE_ID) && bindingMetaData.Get <string>(CORE_ID).Equals(coreUrl)));
Bind(solrReadOnlyOperations).To(solrServer)
.Named(coreUrl)
.WithMetadata(CORE_ID, coreUrl)
.WithConstructorArgument("basicServer", ctx => ctx.Kernel.Get(solrBasicReadOnlyOperations, bindingMetaData => bindingMetaData.Has(CORE_ID) && bindingMetaData.Get <string>(CORE_ID).Equals(coreUrl)));
}
}
break;
case "lucene":
Bind <AbstractConnectionDependencies>().To <LuceneDependencies>().WhenInjectedInto <LuceneConnection>().WithConstructorArgument("processName", _process.Name);
Bind <AbstractConnection>().To <LuceneConnection>().Named(provider);
break;
case "web":
Bind <AbstractConnectionDependencies>().To <WebDependencies>().WhenInjectedInto <WebConnection>();
Bind <AbstractConnection>().To <WebConnection>().Named(provider);
break;
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// SolrNet
var mapper = new MemoizingMappingManager(new AttributesMappingManager());
builder.RegisterInstance(mapper).As <IReadOnlyMappingManager>();
builder.RegisterType <NullCache>().As <ISolrCache>();
builder.RegisterType <DefaultDocumentVisitor>().As <ISolrDocumentPropertyVisitor>();
builder.RegisterType <DefaultFieldParser>().As <ISolrFieldParser>();
builder.RegisterGeneric(typeof(SolrDocumentActivator <>)).As(typeof(ISolrDocumentActivator <>));
builder.RegisterGeneric(typeof(SolrDocumentResponseParser <>)).As(typeof(ISolrDocumentResponseParser <>));
builder.RegisterType <DefaultFieldSerializer>().As <ISolrFieldSerializer>();
builder.RegisterType <DefaultQuerySerializer>().As <ISolrQuerySerializer>();
builder.RegisterType <DefaultFacetQuerySerializer>().As <ISolrFacetQuerySerializer>();
builder.RegisterGeneric(typeof(DefaultResponseParser <>)).As(typeof(ISolrAbstractResponseParser <>));
builder.RegisterType <HeaderResponseParser <string> >().As <ISolrHeaderResponseParser>();
builder.RegisterType <ExtractResponseParser>().As <ISolrExtractResponseParser>();
builder.RegisterType(typeof(MappedPropertiesIsInSolrSchemaRule)).As <IValidationRule>();
builder.RegisterType(typeof(RequiredFieldsAreMappedRule)).As <IValidationRule>();
builder.RegisterType(typeof(UniqueKeyMatchesMappingRule)).As <IValidationRule>();
builder.RegisterType(typeof(MultivaluedMappedToCollectionRule)).As <IValidationRule>();
builder.RegisterType <SolrSchemaParser>().As <ISolrSchemaParser>();
builder.RegisterGeneric(typeof(SolrMoreLikeThisHandlerQueryResultsParser <>)).As(typeof(ISolrMoreLikeThisHandlerQueryResultsParser <>));
builder.RegisterGeneric(typeof(SolrQueryExecuter <>)).As(typeof(ISolrQueryExecuter <>));
builder.RegisterGeneric(typeof(SolrDocumentSerializer <>)).As(typeof(ISolrDocumentSerializer <>));
builder.RegisterType <SolrDIHStatusParser>().As <ISolrDIHStatusParser>();
builder.RegisterType <MappingValidator>().As <IMappingValidator>();
builder.RegisterType <SolrDictionarySerializer>().As <ISolrDocumentSerializer <Dictionary <string, object> > >();
builder.RegisterType <SolrDictionaryDocumentResponseParser>().As <ISolrDocumentResponseParser <Dictionary <string, object> > >();
// connections
foreach (var c in _process.Connections.Where(c => c.Provider.In("solr")))
{
var connection = c;
connection.Url = connection.BuildSolrUrl();
RegisterCore(builder, connection);
builder.Register <ISchemaReader>(ctx => {
Startup.Init <Dictionary <string, object> >(connection.Url);
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(connection.Key);
return(new SolrSchemaReader(connection, solr));
}).Named <ISchemaReader>(connection.Key);
}
// entity input
foreach (var e in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Connection).Provider == "solr"))
{
var entity = e;
builder.Register <IInputProvider>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "solr":
return(new SolrInputProvider(input, ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(input.Connection.Key)));
default:
return(new NullInputProvider());
}
}).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));
switch (input.Connection.Provider)
{
case "solr":
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(input.Connection.Key);
return(new SolrInputReader(solr, input, input.InputFields, rowFactory));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
}
// entity output
if (_process.Output().Provider == "solr")
{
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
foreach (var e in _process.Entities)
{
var entity = e;
// INPUT VALIDATOR
builder.Register <IInputValidator>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
return(new SolrInputValidator(
input,
ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(input.Connection.Key)
));
}).Named <IInputValidator>(entity.Key);
// UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
output.Warn("{0} does not denormalize.", output.Connection.Provider);
return(new NullMasterUpdater());
}).Named <IUpdate>(entity.Key);
// OUTPUT
builder.Register <IOutputProvider>((ctx) => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(output.Connection.Key);
return(new SolrOutputProvider(output, solr));
}).Named <IOutputProvider>(entity.Key);
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "solr":
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(output.Connection.Key);
return(new SolrOutputController(
output,
new NullInitializer(),
ctx.ResolveNamed <IInputProvider>(entity.Key),
ctx.ResolveNamed <IOutputProvider>(entity.Key),
solr
));
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 "solr":
output.Warn("The {0} does not support output yet. Currently the author of this library is using Solr's Data Import Handler for loading SOLR.", output.Connection.Provider);
return(new NullWriter(output));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
}
}
}
public void Build()
{
// SolrNet
var mapper = new MemoizingMappingManager(new AttributesMappingManager());
_builder.RegisterInstance(mapper).As <IReadOnlyMappingManager>();
_builder.RegisterType <NullCache>().As <ISolrCache>();
_builder.RegisterType <DefaultDocumentVisitor>().As <ISolrDocumentPropertyVisitor>();
_builder.RegisterType <DefaultFieldParser>().As <ISolrFieldParser>();
_builder.RegisterGeneric(typeof(SolrDocumentActivator <>)).As(typeof(ISolrDocumentActivator <>));
_builder.RegisterGeneric(typeof(SolrDocumentResponseParser <>)).As(typeof(ISolrDocumentResponseParser <>));
_builder.RegisterType <DefaultFieldSerializer>().As <ISolrFieldSerializer>();
_builder.RegisterType <DefaultQuerySerializer>().As <ISolrQuerySerializer>();
_builder.RegisterType <DefaultFacetQuerySerializer>().As <ISolrFacetQuerySerializer>();
_builder.RegisterGeneric(typeof(DefaultResponseParser <>)).As(typeof(ISolrAbstractResponseParser <>));
_builder.RegisterType <HeaderResponseParser <string> >().As <ISolrHeaderResponseParser>();
_builder.RegisterType <ExtractResponseParser>().As <ISolrExtractResponseParser>();
_builder.RegisterType(typeof(MappedPropertiesIsInSolrSchemaRule)).As <IValidationRule>();
_builder.RegisterType(typeof(RequiredFieldsAreMappedRule)).As <IValidationRule>();
_builder.RegisterType(typeof(UniqueKeyMatchesMappingRule)).As <IValidationRule>();
_builder.RegisterType(typeof(MultivaluedMappedToCollectionRule)).As <IValidationRule>();
_builder.RegisterType <SolrSchemaParser>().As <ISolrSchemaParser>();
_builder.RegisterGeneric(typeof(SolrMoreLikeThisHandlerQueryResultsParser <>)).As(typeof(ISolrMoreLikeThisHandlerQueryResultsParser <>));
_builder.RegisterGeneric(typeof(SolrQueryExecuter <>)).As(typeof(ISolrQueryExecuter <>));
_builder.RegisterGeneric(typeof(SolrDocumentSerializer <>)).As(typeof(ISolrDocumentSerializer <>));
_builder.RegisterType <SolrDIHStatusParser>().As <ISolrDIHStatusParser>();
_builder.RegisterType <MappingValidator>().As <IMappingValidator>();
_builder.RegisterType <SolrDictionarySerializer>().As <ISolrDocumentSerializer <Dictionary <string, object> > >();
_builder.RegisterType <SolrDictionaryDocumentResponseParser>().As <ISolrDocumentResponseParser <Dictionary <string, object> > >();
//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 == Solr)
{
_builder.Register <IMapReader>(ctx => new DefaultMapReader()).Named <IMapReader>(map.Name);
}
}
// connections
foreach (var connection in _process.Connections.Where(c => c.Provider.In(Solr)))
{
connection.Url = connection.BuildSolrUrl();
RegisterCore(_builder, connection);
_builder.Register <ISchemaReader>(ctx => {
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(connection.Key);
return(new SolrSchemaReader(connection, solr));
}).Named <ISchemaReader>(connection.Key);
}
// entity input
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Input).Provider == Solr))
{
_builder.Register <IInputProvider>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case Solr:
return(new SolrInputProvider(input, ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(input.Connection.Key)));
default:
return(new NullInputProvider());
}
}).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));
switch (input.Connection.Provider)
{
case Solr:
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(input.Connection.Key);
return(new SolrInputReader(solr, input, input.InputFields, rowFactory));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
}
// entity output
if (_process.GetOutputConnection().Provider == Solr)
{
// PROCESS OUTPUT CONTROLLER
_builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
foreach (var entity in _process.Entities)
{
// INPUT VALIDATOR
_builder.Register <IInputValidator>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
return(new SolrInputValidator(
input,
ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(input.Connection.Key)
));
}).Named <IInputValidator>(entity.Key);
// 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 <IOutputProvider>((ctx) => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(output.Connection.Key);
return(new SolrOutputProvider(output, solr));
}).Named <IOutputProvider>(entity.Key);
_builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case Solr:
var solr = ctx.ResolveNamed <ISolrReadOnlyOperations <Dictionary <string, object> > >(output.Connection.Key);
var initializer = _process.Mode == "init" ? (IInitializer) new SolrInitializer(
output,
ctx.ResolveNamed <ISolrCoreAdmin>(output.Connection.Key),
ctx.ResolveNamed <ISolrOperations <Dictionary <string, object> > >(output.Connection.Key),
new RazorTemplateEngine(ctx.ResolveNamed <OutputContext>(entity.Key), new Template {
Name = output.Connection.Key, File = "files\\solr\\schema.cshtml"
}, new FileReader()),
new RazorTemplateEngine(ctx.ResolveNamed <OutputContext>(entity.Key), new Template {
Name = output.Connection.Key, File = "files\\solr\\solrconfig.cshtml"
}, new FileReader())
) : new NullInitializer();
return(new SolrOutputController(
output,
initializer,
ctx.ResolveNamed <IInputProvider>(entity.Key),
ctx.ResolveNamed <IOutputProvider>(entity.Key),
solr
));
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 Solr:
if (output.Connection.MaxDegreeOfParallelism > 1)
{
return(new ParallelSolrWriter(output, ctx.ResolveNamed <ISolrOperations <Dictionary <string, object> > >(output.Connection.Key)));
}
else
{
return(new SolrWriter2(output, ctx.ResolveNamed <ISolrOperations <Dictionary <string, object> > >(output.Connection.Key)));
}
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
}
}
}
