/// <summary>
/// Executes this command
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
public string Execute(ISolrConnection connection)
{
var xml = new XmlDocument();
var node = xml.CreateElement("optimize");
foreach (var p in new[] { new KeyValuePair <bool?, string>(WaitSearcher, "waitSearcher"), new KeyValuePair <bool?, string>(WaitFlush, "waitFlush"), new KeyValuePair <bool?, string>(ExpungeDeletes, "expungeDeletes") })
{
if (!p.Key.HasValue)
{
continue;
}
var att = xml.CreateAttribute(p.Value);
att.InnerText = p.Key.Value.ToString().ToLower();
node.Attributes.Append(att);
}
if (MaxSegments.HasValue)
{
var att = xml.CreateAttribute("maxSegments");
att.InnerText = MaxSegments.ToString();
node.Attributes.Append(att);
}
return(connection.Post("/update", node.OuterXml));
}
/// <summary>
/// Initializes SolrNet with the built-in container
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connection"></param>
public static void Init <T>(ISolrConnection connection)
{
var connectionKey = string.Format("{0}.{1}.{2}", typeof(SolrConnection), typeof(T), connection.GetType());
Container.Register(connectionKey, c => connection);
var activator = new SolrDocumentActivator <T>();
Container.Register <ISolrDocumentActivator <T> >(c => activator);
Container.Register(ChooseDocumentResponseParser <T>);
Container.Register <ISolrResponseParser <T> >(typeof(ResultsResponseParser <T>).FullName, c => new ResultsResponseParser <T>(c.GetInstance <ISolrDocumentResponseParser <T> >()));
Container.Register <ISolrResponseParser <T> >(typeof(HeaderResponseParser <T>).FullName, c => new HeaderResponseParser <T>());
Container.Register <ISolrResponseParser <T> >(typeof(FacetsResponseParser <T>).FullName, c => new FacetsResponseParser <T>());
Container.Register <ISolrResponseParser <T> >(typeof(HighlightingResponseParser <T>).FullName, c => new HighlightingResponseParser <T>());
Container.Register <ISolrResponseParser <T> >(typeof(MoreLikeThisResponseParser <T>).FullName, c => new MoreLikeThisResponseParser <T>(c.GetInstance <ISolrDocumentResponseParser <T> >()));
Container.Register <ISolrResponseParser <T> >(typeof(SpellCheckResponseParser <T>).FullName, c => new SpellCheckResponseParser <T>());
Container.Register <ISolrResponseParser <T> >(typeof(StatsResponseParser <T>).FullName, c => new StatsResponseParser <T>());
Container.Register <ISolrResponseParser <T> >(typeof(CollapseResponseParser <T>).FullName, c => new CollapseResponseParser <T>());
Container.Register <ISolrQueryResultParser <T> >(c => new SolrQueryResultParser <T>(c.GetAllInstances <ISolrResponseParser <T> >().ToArray()));
Container.Register <ISolrQueryExecuter <T> >(c => new SolrQueryExecuter <T>(c.GetInstance <ISolrQueryResultParser <T> >(), connection, c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrFacetQuerySerializer>()));
Container.Register(ChooseDocumentSerializer <T>);
Container.Register <ISolrBasicOperations <T> >(c => new SolrBasicServer <T>(connection, c.GetInstance <ISolrQueryExecuter <T> >(), c.GetInstance <ISolrDocumentSerializer <T> >(), c.GetInstance <ISolrSchemaParser>(), c.GetInstance <ISolrHeaderResponseParser>(), c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrDIHStatusParser>(), c.GetInstance <ISolrExtractResponseParser>()));
Container.Register <ISolrBasicReadOnlyOperations <T> >(c => new SolrBasicServer <T>(connection, c.GetInstance <ISolrQueryExecuter <T> >(), c.GetInstance <ISolrDocumentSerializer <T> >(), c.GetInstance <ISolrSchemaParser>(), c.GetInstance <ISolrHeaderResponseParser>(), c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrDIHStatusParser>(), c.GetInstance <ISolrExtractResponseParser>()));
Container.Register <ISolrOperations <T> >(c => new SolrServer <T>(c.GetInstance <ISolrBasicOperations <T> >(), Container.GetInstance <IReadOnlyMappingManager>(), Container.GetInstance <IMappingValidator>()));
Container.Register <ISolrReadOnlyOperations <T> >(c => new SolrServer <T>(c.GetInstance <ISolrBasicOperations <T> >(), Container.GetInstance <IReadOnlyMappingManager>(), Container.GetInstance <IMappingValidator>()));
}
public DSLQueryBetween(string fieldName, ISolrConnection connection, ISolrQuery query, RT from)
{
this.fieldName = fieldName;
this.connection = connection;
this.query = query;
this.from = from;
}
public string Execute(ISolrConnection connection)
{
var xml = new XmlDocument();
var node = xml.CreateElement("commit");
var keyValuePairs = new[] {
new KeyValuePair<bool?, string>(WaitSearcher, "waitSearcher"),
new KeyValuePair<bool?, string>(WaitFlush, "waitFlush"),
new KeyValuePair<bool?, string>(SoftCommit, "softCommit"),
new KeyValuePair<bool?, string>(ExpungeDeletes, "expungeDeletes")
};
foreach (var p in keyValuePairs) {
if (!p.Key.HasValue)
continue;
var att = xml.CreateAttribute(p.Value);
att.InnerText = p.Key.Value.ToString().ToLower();
node.Attributes.Append(att);
}
if (MaxSegments.HasValue) {
var att = xml.CreateAttribute("maxSegments");
att.InnerText = MaxSegments.ToString();
node.Attributes.Append(att);
}
return connection.Post("/update", node.OuterXml);
}
public string Execute(ISolrConnection connection)
{
var xml = new XmlDocument();
var deleteNode = xml.CreateElement("delete");
if (parameters != null) {
if (parameters.CommitWithin.HasValue) {
var attr = xml.CreateAttribute("commitWithin");
attr.Value = parameters.CommitWithin.Value.ToString(CultureInfo.InvariantCulture);
deleteNode.Attributes.Append(attr);
}
}
var param = new[] {
KV.Create(FromPending, "fromPending"),
KV.Create(FromCommitted, "fromCommitted")
};
foreach (var p in param) {
if (p.Key.HasValue) {
var att = xml.CreateAttribute(p.Value);
att.InnerText = p.Key.Value.ToString().ToLower();
deleteNode.Attributes.Append(att);
}
}
deleteNode.InnerXml = string.Join("", deleteParam.ToXmlNode().Select(n => n.OuterXml).ToArray());
return connection.Post("/update", deleteNode.OuterXml);
}
public Uri GetQuery(ISolrConnection connection, ISolrQuery query, Commands.Parameters.QueryOptions options)
{
var executor = new SolrQueryExecuter <object>(null, connection, querySerializer, facetQuerySerializer, null);
var param = executor.GetAllParameters(query, options);
return(connection.GetQuery(SolrQueryExecuter <object> .DefaultHandler, param));
}
public string Execute(ISolrConnection connection)
{
var node = new XElement("commit");
var keyValuePairs = new[] {
new KeyValuePair <bool?, string>(WaitSearcher, "waitSearcher"),
new KeyValuePair <bool?, string>(WaitFlush, "waitFlush"),
new KeyValuePair <bool?, string>(ExpungeDeletes, "expungeDeletes")
};
foreach (var p in keyValuePairs)
{
if (!p.Key.HasValue)
{
continue;
}
var att = new XAttribute(p.Value, p.Key.Value.ToString().ToLower());
node.Add(att);
}
if (MaxSegments.HasValue)
{
var att = new XAttribute("maxSegments", MaxSegments.ToString());
node.Add(att);
}
return(connection.Post("/update", node.ToString(SaveOptions.DisableFormatting)));
}
/// <summary>
/// Initializes a new instance of the <see cref="SolrCoreReplication"/> class.
/// </summary>
public SolrCoreReplication(ISolrConnection connection, ISolrReplicationStatusResponseParser statusParser, ISolrReplicationIndexVersionResponseParser indexversionParser, ISolrReplicationDetailsResponseParser detailsParser)
{
this.connection = connection;
this.statusParser = statusParser;
this.indexversionParser = indexversionParser;
this.detailsParser = detailsParser;
}
/// <summary>
/// Initializes SolrNet with the built-in container
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connection"></param>
public static void Init <T>(ISolrConnection connection)
{
var connectionKey = string.Format("{0}.{1}.{2}", typeof(SolrConnection), typeof(T), connection.GetType());
Container.Register(connectionKey, c => connection);
var activator = new SolrDocumentActivator <T>();
Container.Register <ISolrDocumentActivator <T> >(c => activator);
Container.Register(ChooseDocumentResponseParser <T>);
Container.Register <ISolrAbstractResponseParser <T> >(c => new DefaultResponseParser <T>(c.GetInstance <ISolrDocumentResponseParser <T> >()));
Container.Register <ISolrMoreLikeThisHandlerQueryResultsParser <T> >(c => new SolrMoreLikeThisHandlerQueryResultsParser <T>(c.GetAllInstances <ISolrAbstractResponseParser <T> >().ToArray()));
Container.Register <ISolrQueryExecuter <T> >(c => new SolrQueryExecuter <T>(c.GetInstance <ISolrAbstractResponseParser <T> >(), connection, c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrFacetQuerySerializer>(), c.GetInstance <ISolrMoreLikeThisHandlerQueryResultsParser <T> >()));
Container.Register(ChooseDocumentSerializer <T>);
Container.Register <ISolrBasicOperations <T> >(c => new SolrBasicServer <T>(connection, c.GetInstance <ISolrQueryExecuter <T> >(), c.GetInstance <ISolrDocumentSerializer <T> >(), c.GetInstance <ISolrSchemaParser>(), c.GetInstance <ISolrHeaderResponseParser>(), c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrDIHStatusParser>(), c.GetInstance <ISolrExtractResponseParser>()));
Container.Register <ISolrBasicReadOnlyOperations <T> >(c => new SolrBasicServer <T>(connection, c.GetInstance <ISolrQueryExecuter <T> >(), c.GetInstance <ISolrDocumentSerializer <T> >(), c.GetInstance <ISolrSchemaParser>(), c.GetInstance <ISolrHeaderResponseParser>(), c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrDIHStatusParser>(), c.GetInstance <ISolrExtractResponseParser>()));
Container.Register <ISolrOperations <T> >(c => new SolrServer <T>(c.GetInstance <ISolrBasicOperations <T> >(), Container.GetInstance <IReadOnlyMappingManager>(), Container.GetInstance <IMappingValidator>()));
Container.Register <ISolrReadOnlyOperations <T> >(c => new SolrServer <T>(c.GetInstance <ISolrBasicOperations <T> >(), Container.GetInstance <IReadOnlyMappingManager>(), Container.GetInstance <IMappingValidator>()));
var coreAdminKey = typeof(ISolrCoreAdmin).Name + connectionKey;
Container.Register <ISolrCoreAdmin>(coreAdminKey, c => new SolrCoreAdmin(connection, c.GetInstance <ISolrHeaderResponseParser>(), c.GetInstance <ISolrStatusResponseParser>()));
}
/// <summary>
/// Initializes a new instance of the <see cref="SolrCoreReplication"/> class.
/// </summary>
public SolrCoreReplication(ISolrConnection connection, ISolrReplicationStatusResponseParser statusParser, ISolrReplicationIndexVersionResponseParser indexversionParser, ISolrReplicationDetailsResponseParser detailsParser)
{
this.connection = connection;
this.statusParser = statusParser;
this.indexversionParser = indexversionParser;
this.detailsParser = detailsParser;
}
/// <summary>
/// Connects to the specified Solr server URL.
/// </summary>
/// <param name="serverURL">The server URL.</param>
/// <param name="timeout">The HTTP connection timeout.</param>
public static void Connect(string serverURL, int timeout)
{
Connection = new SolrConnection(serverURL)
{
Timeout = timeout
};
}
public string Execute(ISolrConnection connection)
{
var xml = ConvertToXml();
xml = RemoveControlCharacters(xml);
return(connection.Post("/update", xml));
}
public string Execute(ISolrConnection connection)
{
var xml = new XmlDocument();
var deleteNode = xml.CreateElement("delete");
if (parameters != null)
{
if (parameters.CommitWithin.HasValue)
{
var attr = xml.CreateAttribute("commitWithin");
attr.Value = parameters.CommitWithin.Value.ToString(CultureInfo.InvariantCulture);
deleteNode.Attributes.Append(attr);
}
}
var param = new[] {
KV.Create(FromPending, "fromPending"),
KV.Create(FromCommitted, "fromCommitted")
};
foreach (var p in param)
{
if (p.Key.HasValue)
{
var att = xml.CreateAttribute(p.Value);
att.InnerText = p.Key.Value.ToString().ToLower();
deleteNode.Attributes.Append(att);
}
}
deleteNode.InnerXml = string.Join("", deleteParam.ToXmlNode().Select(n => n.OuterXml).ToArray());
return(connection.Post("/update", deleteNode.OuterXml));
}
public string Execute(ISolrConnection connection)
{
var deleteNode = new XElement("delete");
if (parameters != null)
{
if (parameters.CommitWithin.HasValue)
{
var attr = new XAttribute("commitWithin", parameters.CommitWithin.Value.ToString(CultureInfo.InvariantCulture));
deleteNode.Add(attr);
}
}
var param = new[] {
KV.Create(FromPending, "fromPending"),
KV.Create(FromCommitted, "fromCommitted")
};
foreach (var p in param)
{
if (p.Key.HasValue)
{
var att = new XAttribute(p.Value, p.Key.Value.ToString().ToLower());
deleteNode.Add(att);
}
}
deleteNode.Add(deleteParam.ToXmlNode().ToArray());
return(connection.Post("/update", deleteNode.ToString(SaveOptions.DisableFormatting)));
}
/// <summary>
/// Executes this command
/// </summary>
/// <param name="connection">The Solr connection</param>
/// <returns></returns>
public async Task <string> Execute(ISolrConnection connection)
{
string flux = string.Empty;
JObject json = new JObject();
foreach (var item in this.documents)
{
var cmd = new SolrAddRootCommandObject <T>(item.Key);
flux = JsonConvert.SerializeObject(cmd);
PropertyInfo[] myPropertyInfo;
Dictionary <string, object> dictionnaryProperties = new Dictionary <string, object>();
myPropertyInfo = Type.GetType(typeof(T).AssemblyQualifiedName).GetProperties();
for (int i = 0; i < myPropertyInfo.Length; i++)
{
dictionnaryProperties = myPropertyInfo[i].GetPropertyAttributes(dictionnaryProperties);
}
json = JObject.Parse(flux);
var fieldDictionaryList = new List <string>();
foreach (var dictionaryItem in dictionnaryProperties)
{
fieldDictionaryList.Add(dictionaryItem.Key);
}
string formattedFlux = RemoveFields(json.SelectToken("add.doc"), fieldDictionaryList).ToString();
}
return(await connection.Post("/update", json.ToString()));
}
public Task <string> ExecuteAsync(ISolrConnection connection)
{
string json = GetAtomicUpdateJson();
var bytes = Encoding.UTF8.GetBytes(json);
using (var content = new MemoryStream(bytes))
return(connection.PostStreamAsync("/update", "text/json; charset=utf-8", content, GetParamsAsKvp()));
}
public SolrQueryExecuter(ISolrQueryResultParser <T> resultParser, ISolrConnection connection, ISolrQuerySerializer querySerializer, ISolrFacetQuerySerializer facetQuerySerializer)
{
this.resultParser = resultParser;
this.connection = connection;
this.querySerializer = querySerializer;
this.facetQuerySerializer = facetQuerySerializer;
DefaultRows = ConstDefaultRows;
}
public async Task <string> Execute(ISolrConnection connection)
{
SolrCommitRootCommandObject cmd = new SolrCommitRootCommandObject();
string flux = JsonConvert.SerializeObject(cmd);
return(await connection.Post("/update", flux));
}
/// <summary>
/// Executes the SOLR delta import for specified collection.
/// </summary>
/// <param name="connection">Connection that specify collection to update.</param>
/// <returns>Result of the operation.</returns>
public string Execute(ISolrConnection connection)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
return connection.Post("/dataimport?command=delta-import", string.Empty);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="resultParser"></param>
/// <param name="connection"></param>
/// <param name="querySerializer"></param>
/// <param name="facetQuerySerializer"></param>
/// <param name="mlthResultParser"></param>
public SolrQueryExecuter(ISolrConnection connection, ISolrQuerySerializer querySerializer, ISolrFacetQuerySerializer facetQuerySerializer)
{
this.connection = connection;
this.querySerializer = querySerializer;
this.facetQuerySerializer = facetQuerySerializer;
DefaultRows = ConstDefaultRows;
Handler = DefaultHandler;
MoreLikeThisHandler = DefaultMoreLikeThisHandler;
}
public void TestCache(ISolrConnection conn)
{
foreach (var i in Enumerable.Range(0, 1000))
{
conn.Get("/select/", new Dictionary <string, string> {
{ "q", "*:*" },
});
}
}
/// <summary>
/// Make a new CrownPeakQueryExecuter
/// </summary>
/// <param name="resultParser"></param>
/// <param name="connection"></param>
/// <param name="querySerializer"></param>
/// <param name="facetQuerySerializer"></param>
/// <param name="mlthResultParser"></param>
public CrownPeakQueryExecuter(ISolrAbstractResponseParser <T> resultParser,
ISolrConnection connection, ISolrQuerySerializer querySerializer,
ISolrFacetQuerySerializer facetQuerySerializer,
ISolrMoreLikeThisHandlerQueryResultsParser <T> mlthResultParser)
: base(resultParser, connection, querySerializer, facetQuerySerializer, mlthResultParser)
{
_parser = resultParser as ICrownPeakResponseParser <T>;
_connection = connection;
}
public SolrBasicServer(ISolrConnection connection, ISolrQueryExecuter <T> queryExecuter, ISolrDocumentSerializer <T> documentSerializer, ISolrSchemaParser schemaParser, ISolrHeaderResponseParser headerParser, ISolrQuerySerializer querySerializer, ISolrDIHStatusParser dihStatusParser, ISolrExtractResponseParser extractResponseParser)
: base(connection, headerParser)
{
this.extractResponseParser = extractResponseParser;
this.queryExecuter = queryExecuter;
this.documentSerializer = documentSerializer;
this.schemaParser = schemaParser;
this.querySerializer = querySerializer;
this.dihStatusParser = dihStatusParser;
}
/// <summary>
/// Default constructor of class
/// </summary>
public DocumentUpdate(
ISolrConnection solrConnection,
ISolrExpressServiceProvider <TDocument> serviceProvider)
{
Checker.IsNull(solrConnection);
Checker.IsNull(serviceProvider);
this._solrConnection = solrConnection;
this.ServiceProvider = serviceProvider;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="resultParser"></param>
/// <param name="connection"></param>
/// <param name="querySerializer"></param>
/// <param name="facetQuerySerializer"></param>
/// <param name="mlthResultParser"></param>
public SolrQueryExecuter(ISolrAbstractResponseParser <T> resultParser, ISolrConnection connection, ISolrQuerySerializer querySerializer, ISolrFacetQuerySerializer facetQuerySerializer, ISolrMoreLikeThisHandlerQueryResultsParser <T> mlthResultParser)
{
this.resultParser = resultParser;
this.mlthResultParser = mlthResultParser;
this.connection = connection;
this.querySerializer = querySerializer;
this.facetQuerySerializer = facetQuerySerializer;
DefaultRows = ConstDefaultRows;
MoreLikeThisHandler = DefaultMoreLikeThisHandler;
}
public SolrBasicServer(ISolrConnection connection, ISolrQueryExecuter <T> queryExecuter, ISolrQuerySerializer querySerializer, ISolrExtractResponseParser extractResponseParser = null)
{
this.connection = connection;
//this.extractResponseParser = extractResponseParser;
this.queryExecuter = queryExecuter;
//this.documentSerializer = documentSerializer;
//this.schemaParser = schemaParser;
//this.headerParser = headerParser;
this.querySerializer = querySerializer;
//this.dihStatusParser = dihStatusParser;
}
public SolrSearchService(
IPostRepository posts,
ISolrOperations <Post> postOp,
ISolrConnection connection,
IConfigurationService service)
{
this.posts = posts;
this.postOp = postOp;
this.connection = connection;
this.service = service;
}
public DSLQueryRange(ISolrConnection connection, ISolrQuery query, string fieldName, RT from, RT to) : base(connection)
{
this.query = new SolrMultipleCriteriaQuery(new[] {
query,
new SolrQueryByRange <RT>(fieldName, from, to)
});
prevQuery = query;
this.fieldName = fieldName;
this.from = from;
this.to = to;
}
public SolrSearchService(
IPostRepository posts,
ISolrOperations<Post> postOp,
ISolrConnection connection,
IConfigurationService service)
{
this.posts = posts;
this.postOp = postOp;
this.connection = connection;
this.service = service;
}
/// <summary>
/// Executes this command
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
public string Execute(ISolrConnection connection)
{
var xml = new XmlDocument();
var node = xml.CreateElement("optimize");
foreach (var p in new[] {new KeyValuePair<bool?, string>(WaitSearcher, "waitSearcher"), new KeyValuePair<bool?, string>(WaitFlush, "waitFlush")}) {
if (p.Key.HasValue) {
var att = xml.CreateAttribute(p.Value);
att.InnerText = p.Key.Value.ToString().ToLower();
node.Attributes.Append(att);
}
}
return connection.Post("/update", node.OuterXml);
}
public string Execute(ISolrConnection connection)
{
var xml = new XmlDocument();
var deleteNode = xml.CreateElement("delete");
foreach (var p in new[] {new KeyValuePair<bool?, string>(FromPending, "fromPending"), new KeyValuePair<bool?, string>(FromCommitted, "fromCommitted")}) {
if (p.Key.HasValue) {
var att = xml.CreateAttribute(p.Value);
att.InnerText = p.Key.Value.ToString().ToLower();
deleteNode.Attributes.Append(att);
}
}
deleteNode.InnerXml = Func.Join(Func.Select(deleteParam.ToXmlNode(), n => n.OuterXml));
return connection.Post("/update", deleteNode.OuterXml);
}
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);
}
/// <summary>
/// Initializes SolrNet with the built-in container
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connection"></param>
public static void Init <T>(ISolrConnection connection)
{
var connectionKey = string.Format("{0}.{1}.{2}", typeof(SolrConnection), typeof(T), connection.GetType());
Container.Register(connectionKey, c => connection);
var activator = new SolrDocumentActivator <T>();
Container.Register <ISolrDocumentActivator <T> >(c => activator);
Container.Register <ISolrQueryExecuter <T> >(c => new SolrQueryExecuter <T>(connection, c.GetInstance <ISolrQuerySerializer>(), c.GetInstance <ISolrFacetQuerySerializer>()));
Container.Register <ISolrBasicOperations <T> >(c => new SolrBasicServer <T>(connection, c.GetInstance <ISolrQueryExecuter <T> >(), c.GetInstance <ISolrQuerySerializer>())); //todo
Container.Register <ISolrBasicReadOnlyOperations <T> >(c => new SolrBasicServer <T>(connection, c.GetInstance <ISolrQueryExecuter <T> >(), c.GetInstance <ISolrQuerySerializer>())); //todo
Container.Register <ISolrOperations <T> >(c => new SolrServer <T>(c.GetInstance <ISolrBasicOperations <T> >(), Container.GetInstance <IReadOnlyMappingManager>()));
Container.Register <ISolrReadOnlyOperations <T> >(c => new SolrServer <T>(c.GetInstance <ISolrBasicOperations <T> >(), Container.GetInstance <IReadOnlyMappingManager>()));
}
public ISolrOperations <T> GetServer(ISolrConnection connection)
{
var basicServer = GetBasicServer(connection);
MappingValidator = new MappingValidator(MappingManager, new IValidationRule[]
{
new MappedPropertiesIsInSolrSchemaRule(),
new RequiredFieldsAreMappedRule(),
new UniqueKeyMatchesMappingRule(),
new MultivaluedMappedToCollectionRule()
});
ISolrOperations <T> server = new SolrServer <T>(basicServer, MappingManager, MappingValidator);
return(server);
}
/// <summary>
/// Initializes the Solr service with a connection to solr.
/// </summary>
/// <param name="connection">The solr connection to use.</param>
/// <param name="force">If true, this will reinitialize the server connection if one already exists.</param>
public static void Init(ISolrConnection connection, bool force = false)
{
if (force)
{
ClearContainer();
}
if (!IsInitialized)
{
mSolr = connection;
Startup.Init <SolrIndex>(mSolr);
Startup.Init <Dictionary <string, object> >(mSolr);
SolrOperations = ServiceLocator.Current.GetInstance <ISolrOperations <Dictionary <string, object> > >();
IsInitialized = true;
//IsSolrInitialized = true;
}
}
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 string Execute(ISolrConnection connection) {
var deleteNode = new XElement("delete");
if (parameters != null) {
if (parameters.CommitWithin.HasValue) {
var attr = new XAttribute("commitWithin", parameters.CommitWithin.Value.ToString(CultureInfo.InvariantCulture));
deleteNode.Add(attr);
}
}
var param = new[] {
KV.Create(FromPending, "fromPending"),
KV.Create(FromCommitted, "fromCommitted")
};
foreach (var p in param) {
if (p.Key.HasValue) {
var att = new XAttribute(p.Value, p.Key.Value.ToString().ToLower());
deleteNode.Add(att);
}
}
deleteNode.Add(deleteParam.ToXmlNode().ToArray());
return connection.Post("/update", deleteNode.ToString(SaveOptions.DisableFormatting));
}
public string Execute(ISolrConnection connection) {
var node = new XElement("commit");
var keyValuePairs = new[] {
new KeyValuePair<bool?, string>(WaitSearcher, "waitSearcher"),
new KeyValuePair<bool?, string>(WaitFlush, "waitFlush"),
new KeyValuePair<bool?, string>(ExpungeDeletes, "expungeDeletes")
};
foreach (var p in keyValuePairs) {
if (!p.Key.HasValue)
continue;
var att = new XAttribute(p.Value, p.Key.Value.ToString().ToLower());
node.Add(att);
}
if (MaxSegments.HasValue) {
var att = new XAttribute("maxSegments", MaxSegments.ToString());
node.Add(att);
}
return connection.Post("/update", node.ToString(SaveOptions.DisableFormatting));
}
public DeleteBy(ISolrConnection connection)
{
this.connection = connection;
}
/// <summary>
/// Gets the raw Solr schema
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
public string Execute(ISolrConnection connection)
{
return connection.Get("/admin/file", new[] {new KeyValuePair<string, string>("file", "schema.xml")});
}
public void TestCache(ISolrConnection conn)
{
foreach (var i in Enumerable.Range(0, 1000)) {
conn.Get("/select/", new Dictionary<string, string> {
{"q", "*:*"},
});
}
}
/// <summary>
/// Executes a Replication command
/// </summary>
/// <param name="connection">The SolrConnection to use.</param>
/// <returns>The results of the Command.</returns>
public string Execute(ISolrConnection connection)
{
return connection.Get("/replication", Parameters.ToArray());
}
public ConsoleLoggingConnection(string url)
{
connection = new SolrConnection(url);
}
/// <summary>
/// Builds an instance of core admin manager with the specified connection
/// </summary>
/// <param name="conn"></param>
/// <returns></returns>
public ISolrCoreAdmin BuildCoreAdmin(ISolrConnection conn)
{
return(new SolrCoreAdmin(conn, Kernel.Resolve <ISolrHeaderResponseParser>(), Kernel.Resolve <ISolrStatusResponseParser>()));
}
public string Execute(ISolrConnection connection)
{
return connection.Get("/admin/ping", new Dictionary<string, string>());
}
/// <summary>
/// Initializes a new instance of the <see cref="SolrCoreAdmin"/> class.
/// </summary>
/// <param name="connection">The connection.</param>
public SolrCoreAdmin(ISolrConnection connection)
{
this.connection = connection;
}
/// <summary>
/// Initializes a new instance of the <see cref="SolrCoreAdmin"/> class.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="headerParser">The header parser.</param>
public SolrCoreAdmin(ISolrConnection connection, ISolrHeaderResponseParser headerParser)
{
this.connection = connection;
this.headerParser = headerParser;
}
public Uri GetQuery(ISolrConnection connection, ISolrQuery query, Commands.Parameters.QueryOptions options)
{
var executor = new SolrQueryExecuter<object>(null, connection, querySerializer, facetQuerySerializer, null);
var param = executor.GetAllParameters(query, options);
return connection.GetQuery(SolrQueryExecuter<object>.DefaultHandler, param);
}
public PostSolrConnection(ISolrConnection conn, string serverUrl)
{
this.conn = conn;
this.serverUrl = serverUrl;
}
/// <summary>
/// Builds an instance of core admin manager with the specified connection
/// </summary>
/// <param name="conn"></param>
/// <returns></returns>
public ISolrCoreAdmin BuildCoreAdmin(ISolrConnection conn) {
return new SolrCoreAdmin(conn, Kernel.Resolve<ISolrHeaderResponseParser>(), Kernel.Resolve<ISolrStatusResponseParser>());
}
/// <summary>
/// Executes a Core command
/// </summary>
/// <param name="connection">The SolrConnection to use.</param>
/// <returns>The results of the Command.</returns>
public string Execute(ISolrConnection connection)
{
return connection.Get("/admin/cores", Parameters.ToArray());
}
public SearchConnection(ISolrConnection connection)
{
this.connection = connection;
}
public LoggingConnection(ISolrConnection connection)
{
this.connection = connection;
}
public string Execute(ISolrConnection connection)
{
return connection.Post("/update", "<rollback/>");
}
/// <summary>
/// Initializes a new instance of the <see cref="SolrCoreAdmin"/> class.
/// </summary>
public SolrCoreAdmin(ISolrConnection connection, ISolrHeaderResponseParser headerParser, ISolrStatusResponseParser resultParser) {
this.connection = connection;
this.headerParser = headerParser;
this.resultParser = resultParser;
}
public string Execute(ISolrConnection connection) {
var queryParameters = ConvertToQueryParameters();
return connection.PostStream("/update/extract", parameters.StreamType, parameters.Content, queryParameters);
}
