private void RegisterSingleCore(ContainerBuilder builder)
{
RegisterCommonComponents(builder);
SolrConnection solrConnection = new SolrConnection(ServerUrl);
if (HttpWebRequestFactory != null)
{
solrConnection.HttpWebRequestFactory = HttpWebRequestFactory;
}
builder.RegisterInstance(solrConnection).As <ISolrConnection>();
builder.RegisterGeneric(typeof(SolrBasicServer <>))
.As(typeof(ISolrBasicOperations <>), typeof(ISolrBasicReadOnlyOperations <>))
.SingleInstance();
builder.RegisterGeneric(typeof(SolrServer <>))
.As(typeof(ISolrOperations <>), typeof(ISolrReadOnlyOperations <>))
.SingleInstance();
}
public void WithWtXml_Get()
{
var expected = "https://pepe/?wt=xml&version=2.2";
var cache = new Mocks.MSolrCache();
cache.get += url => new SolrCacheEntity(url, "etag", "hello xml world");
cache.add &= x => x.Stub();
var headers = new WebHeaderCollection
{
{ HttpResponseHeader.ETag, "etag" }, { HttpResponseHeader.CacheControl, "cache" }
};
var response = new Mocks.HttpWebResponse
{
dispose = () => { },
headers = () => headers,
getResponseStream = () => new MemoryStream(Encoding.UTF8.GetBytes("hello xml world")),
};
var request = new Mocks.HttpWebRequest
{
getResponse = () => response,
Headers = new WebHeaderCollection()
};
var reqFactory = new Mocks.HttpWebRequestFactory
{
create = _ => request
};
var conn = new SolrConnection("https://pepe")
{
HttpWebRequestFactory = reqFactory,
Cache = cache
};
var r = conn.Get("", new Dictionary <string, string>( ));
var actual = conn.Cache[expected];
Assert.Equal("hello xml world", r);
Assert.Equal(actual.Url, expected);
}
public void Get()
{
var response = new Mocks.HttpWebResponse {
dispose = () => {},
headers = () => new WebHeaderCollection(),
getResponseStream = () => new MemoryStream(Encoding.UTF8.GetBytes("hello world")),
};
var request = new Mocks.HttpWebRequest {
getResponse = () => response
};
var reqFactory = new Mocks.HttpWebRequestFactory {
create = _ => request
};
var conn = new SolrConnection("https://pepe")
{
HttpWebRequestFactory = reqFactory,
};
var r = conn.Get("", new Dictionary <string, string>());
Assert.Equal("hello world", r);
}
public Indexer()
{
if (Configuration.IndexerServer == string.Empty)
{
throw new Exception("No indexer server was found");
}
if (Configuration.EnableLogging)
{
XmlConfigurator.ConfigureAndWatch(new FileInfo(Path.Combine(HttpContext.Current.Server.MapPath("/"), "log4net.config")));
var connection = new SolrConnection(Configuration.IndexerServer);
var loggingConnection = new LoggingConnection(connection);
Startup.Init <NewsRepository>(loggingConnection);
}
else
{
Startup.Init <NewsRepository>(Configuration.IndexerServer);
}
}
/// <summary>
/// Initializes the SolrConnection if not already initialized for the given Server Url and Core Name.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="solrServerUrl"></param>
/// <param name="coreName"></param>
public static void InitConnection <T>(string solrServerUrl, string coreName)
{
var coreUrl = solrServerUrl + coreName;
if (InitializedCoreUrls.Any(x => x.Equals(coreUrl, StringComparison.OrdinalIgnoreCase)))
{
return;
}
//https://localhost/solr/product
//https://localhost/solr/product_translated
var connection = new SolrConnection(solrServerUrl + coreName);
var loggingConnection = new LoggingConnection(connection);
Startup.Init <T>(loggingConnection);
var obj = new object();
lock (obj)
{
InitializedCoreUrls.Add(coreUrl);
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var url = $"{_options.Uri}/{_options.Core}";
if (!_connections.TryGetValue(url, out SolrConnection solrConnection))
{
solrConnection = new SolrConnection(url);
solrConnection.Timeout = (int)_options.Timeout.TotalMilliseconds;
if (!_connections.TryAdd(url, solrConnection))
{
solrConnection = _connections[url];
}
}
var server = new SolrBasicServer <string>(
solrConnection,
queryExecuter: null,
documentSerializer: null,
schemaParser: null,
headerParser: null,
querySerializer: null,
dihStatusParser: null,
extractResponseParser: null);
var result = await server.PingAsync();
var isSuccess = result.Status == 0;
return(isSuccess
? HealthCheckResult.Healthy()
: new HealthCheckResult(context.Registration.FailureStatus));
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public void InvalidHostPost_ShouldThrowException()
{
var mocks = new MockRepository();
var reqFactory = mocks.StrictMock <IHttpWebRequestFactory>();
var request = mocks.DynamicMock <IHttpWebRequest>();
With.Mocks(mocks).Expecting(delegate {
Expect.Call(request.GetRequestStream())
.Repeat.Once()
.Throw(new WebException());
Expect.Call(reqFactory.Create(new Uri("http://lalala:12345/update")))
.IgnoreArguments()
.Repeat.Once()
.Return(request);
}).Verify(delegate {
var conn = new SolrConnection("http://lalala:12345")
{
HttpWebRequestFactory = reqFactory
};
conn.Post("/update", "");
});
}
/// <summary>
/// Registers a new core in the container.
/// This method is meant to be used after the facility initialization
/// </summary>
/// <param name="core"></param>
private void RegisterCore(SolrCore core)
{
var coreConnectionId = core.Id + typeof(SolrConnection);
var solrConnection = new SolrConnection(core.Url);
Kernel.Register(
Component.For <ISolrConnection>()
.ImplementedBy <PostSolrConnection>()
.Named(coreConnectionId)
.DependsOn(
Property.ForKey("conn").Eq(solrConnection),
Property.ForKey("serverURL").Eq(core.Url)));
var ISolrQueryExecuter = typeof(ISolrQueryExecuter <>).MakeGenericType(core.DocumentType);
var SolrQueryExecuter = typeof(SolrQueryExecuter <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrQueryExecuter).ImplementedBy(SolrQueryExecuter)
.Named(core.Id + SolrQueryExecuter)
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(coreConnectionId)));
var ISolrBasicOperations = typeof(ISolrBasicOperations <>).MakeGenericType(core.DocumentType);
var ISolrBasicReadOnlyOperations = typeof(ISolrBasicReadOnlyOperations <>).MakeGenericType(core.DocumentType);
var SolrBasicServer = typeof(SolrBasicServer <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrBasicOperations, ISolrBasicReadOnlyOperations)
.ImplementedBy(SolrBasicServer)
.Named(core.Id + SolrBasicServer)
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(coreConnectionId),
ServiceOverride.ForKey("queryExecuter").Eq(core.Id + SolrQueryExecuter)));
var ISolrOperations = typeof(ISolrOperations <>).MakeGenericType(core.DocumentType);
var SolrServer = typeof(SolrServer <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrOperations).ImplementedBy(SolrServer)
.Named(core.Id)
.ServiceOverrides(ServiceOverride.ForKey("basicServer").Eq(core.Id + SolrBasicServer)));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
Bootstrapper.Initialise();
var license = new License();
var commonAssembly = System.Reflection.Assembly.Load("VAV.DAL");
var s = commonAssembly.GetManifestResourceStream("VAV.DAL.Aspose.Cells.lic");
license.SetLicense(s);
new UIStaticDataCache();
var solrServer = ConfigurationManager.AppSettings["SolrServer"];
var connection0 = new SolrConnection("http://" + solrServer + ":8983/solr/core0");
var connection1 = new SolrConnection("http://" + solrServer + ":8983/solr/core1");
Startup.Init <SearchContentViewModel>(connection0);
Startup.Init <AutoSuggestViewModel>(connection1);
}
public JsonResult Suggestions(string searchText)
{
var solr = new SolrConnection(SolrConfig.VehicleInformationIndex);
var parameters = new Dictionary <string, string>
{
{ "spellcheck.q", searchText },
{ "wt", "json" }
};
var response = solr.Get("/suggest", parameters);
var suggestion = JsonConvert.DeserializeObject <SuggestionModel>(response);
if (suggestion.Spellcheck == null)
{
return(null);
}
var details = JsonConvert.DeserializeObject <SuggestionDetailModel>(suggestion.Spellcheck.Suggestions.ToList()[1].ToString());
details.SearchText = searchText;
return(Json(details));
}
public void Get_Compressed_Gzip()
{
var mocks = new MockRepository();
var reqFactory = mocks.StrictMock <IHttpWebRequestFactory>();
var request = mocks.DynamicMock <IHttpWebRequest>();
var response = mocks.DynamicMock <IHttpWebResponse>();
With.Mocks(mocks).Expecting(delegate
{
Expect.Call(reqFactory.Create(new UriBuilder().Uri))
.IgnoreArguments()
.Repeat.Once()
.Return(request);
Expect.Call(request.Headers)
.Repeat.Any()
.Return(new WebHeaderCollection());
Expect.Call(response.ContentEncoding)
.Repeat.Any()
.Return("gzip");
Expect.Call(response.Headers)
.Repeat.Any()
.Return(new WebHeaderCollection());
Expect.Call(request.GetResponse())
.Repeat.Once()
.Return(response);
Expect.Call(response.GetResponseStream())
.Repeat.Once()
.Return(CompressionUtils.GzipCompressStream("Testing compression"));
}).Verify(delegate {
var conn = new SolrConnection("http://localhost")
{
HttpWebRequestFactory = reqFactory
};
Assert.AreEqual("Testing compression", conn.Get("", new Dictionary <string, string>()));
});
}
protected override void Init()
{
var mapper = Mapper ?? new MemoizingMappingManager(new AttributesMappingManager());
Kernel.Register(Component.For <IReadOnlyMappingManager>().Instance(mapper));
//Kernel.Register(Component.For<ISolrCache>().ImplementedBy<HttpRuntimeCache>());
var solrConnection = new SolrConnection(this.GetSolrUrl());
Kernel.Register(Component.For <ISolrConnection>().ImplementedBy <PostSolrConnection>()
.DependsOn(
Property.ForKey("serverURL").Eq(solrConnection),
Property.ForKey("serverURL").Eq(GetSolrUrl()))
);
Kernel.Register(Component.For(typeof(ISolrDocumentActivator <>)).ImplementedBy(typeof(SolrDocumentActivator <>)));
Kernel.Register(Component.For(typeof(ISolrDocumentResponseParser <>))
.ImplementedBy(typeof(SolrDocumentResponseParser <>)));
Kernel.Register(Component.For <ISolrDocumentResponseParser <Dictionary <string, object> > >()
.ImplementedBy <SolrDictionaryDocumentResponseParser>());
Kernel.Register(Component.For(typeof(ISolrAbstractResponseParser <>)).ImplementedBy(typeof(DefaultResponseParser <>)));
Kernel.Register(Component.For <ISolrHeaderResponseParser>().ImplementedBy <HeaderResponseParser <string> >());
Kernel.Register(Component.For <ISolrExtractResponseParser>().ImplementedBy <ExtractResponseParser>());
foreach (var validationRule in new[] {
typeof(MappedPropertiesIsInSolrSchemaRule),
typeof(RequiredFieldsAreMappedRule),
typeof(UniqueKeyMatchesMappingRule),
typeof(MultivaluedMappedToCollectionRule),
})
{
Kernel.Register(Component.For <IValidationRule>().ImplementedBy(validationRule));
}
Kernel.Resolver.AddSubResolver(new StrictArrayResolver(Kernel));
Kernel.Register(Component.For(typeof(ISolrMoreLikeThisHandlerQueryResultsParser <>))
.ImplementedBy(typeof(SolrMoreLikeThisHandlerQueryResultsParser <>)));
Kernel.Register(Component.For(typeof(ISolrQueryExecuter <>)).ImplementedBy(typeof(SolrQueryExecuter <>)));
Kernel.Register(Component.For(typeof(ISolrDocumentSerializer <>))
.ImplementedBy(typeof(SolrDocumentSerializer <>)));
Kernel.Register(Component.For <ISolrDocumentSerializer <Dictionary <string, object> > >()
.ImplementedBy <SolrDictionarySerializer>());
Kernel.Register(Component.For(typeof(ISolrBasicOperations <>), typeof(ISolrBasicReadOnlyOperations <>))
.ImplementedBy(typeof(SolrBasicServer <>)));
Kernel.Register(Component.For(typeof(ISolrOperations <>), typeof(ISolrReadOnlyOperations <>))
.ImplementedBy(typeof(SolrServer <>)));
Kernel.Register(Component.For <ISolrFieldParser>()
.ImplementedBy <DefaultFieldParser>());
Kernel.Register(Component.For <ISolrFieldSerializer>().ImplementedBy <DefaultFieldSerializer>());
Kernel.Register(Component.For <ISolrQuerySerializer>().ImplementedBy <DefaultQuerySerializer>());
Kernel.Register(Component.For <ISolrFacetQuerySerializer>().ImplementedBy <DefaultFacetQuerySerializer>());
Kernel.Register(Component.For <ISolrDocumentPropertyVisitor>().ImplementedBy <DefaultDocumentVisitor>());
Kernel.Register(Component.For <ISolrSchemaParser>().ImplementedBy <SolrSchemaParser>());
Kernel.Register(Component.For <ISolrDIHStatusParser>().ImplementedBy <SolrDIHStatusParser>());
Kernel.Register(Component.For <IMappingValidator>().ImplementedBy <MappingValidator>());
Kernel.Register(Component.For <ISolrStatusResponseParser>().ImplementedBy <SolrStatusResponseParser>());
Kernel.Register(Component.For <ISolrCoreAdmin>().ImplementedBy <SolrCoreAdmin>());
AddCoresFromConfig();
foreach (var core in cores)
{
RegisterCore(core);
}
}
public SolrUpdateHandler(SolrConnection connection)
: base(connection)
{
UniqueField = "id,_route_";
}
public SolrParticipleHandler(SolrConnection connection)
: base(connection)
{
}
private ISolrCoreAdmin BuildCoreAdmin()
{
var connection = new SolrConnection(SolrContentSearchManager.ServiceAddress);
return(_operations.BuildCoreAdmin(connection));
}
/// <summary>
/// Gets server instance
/// </summary>
public static ISolrOperations <T> GetServer <T>(string url, bool isPostConnection)
{
var connection = new SolrConnection(url);
return(!isPostConnection?GetServer <T>(connection) : GetServer <T>(new PostSolrConnection(connection, url)));
}
/// <summary>
/// Initializes SolrNet with the built-in container
/// </summary>
/// <typeparam name="T">Document type</typeparam>
/// <param name="serverURL">Solr URL (i.e. "http://localhost:8983/solr")</param>
public static void Init <T>(string serverURL)
{
var connection = new SolrConnection(serverURL);
Init <T>(connection);
}
public SolrMltHandler(SolrConnection connection)
: base(connection)
{
}
public SolrAnalysisHandler(SolrConnection connection)
: base(connection)
{
}
/// <summary>
/// Builds an instance of core admin manager with the specified URL
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public ISolrCoreAdmin BuildCoreAdmin(string url)
{
var conn = new SolrConnection(url);
return(BuildCoreAdmin(conn));
}
public void Setup()
{
solrconnection = new SolrConnection("http://localhost:8983/solr");
collections = new SolrCollectionsAdmin(solrconnection, new HeaderResponseParser <string>());
}
