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