static void Main(string[] args)
{
RiverConfiguration _riverConfiguration = (RiverConfiguration)ConfigurationManager.GetSection("riverConfiguration");
ConnectionSettings searchSettings = new ConnectionSettings(new Uri(_riverConfiguration.ElasticSearchConnectionString));
var searchClient = new ElasticsearchClient(searchSettings);
while (true)
{
//Connect to DB and listen for a message.
using (SqlConnection sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["queueDatabase"].ConnectionString))
{
sqlConnection.Open();
SqlCommand receiveCommand = new SqlCommand("WAITFOR( RECEIVE TOP(1) CONVERT(XML, message_body) AS Message FROM RiverUpdateReceiveQueue )", sqlConnection);
SqlCommand retrieveDataCommand;
RiverMessage riverMessage;
using (SqlDataReader receiveCommandReader = receiveCommand.ExecuteReader())
{
//Deserialize message.
receiveCommandReader.Read();
XmlSerializer serializer = new XmlSerializer(typeof(RiverMessage));
riverMessage = (RiverMessage)serializer.Deserialize(receiveCommandReader.GetXmlReader(0));
//Get the entire record out of the DB.
retrieveDataCommand = new SqlCommand(string.Format("SELECT TOP(1) * FROM {0} WHERE {1} = {2}", riverMessage.DatabaseTable, _riverConfiguration.Rivers.Cast<RiverElement>().First(x => x.DatabaseTable == riverMessage.DatabaseTable).tableId, riverMessage.Id), sqlConnection);
}
using (SqlDataReader retrieveDataCommandReader = retrieveDataCommand.ExecuteReader())
{
JObject item = null;
//Read it from the DB and store in a simple JSON object.
if (retrieveDataCommandReader.Read())
{
item = new JObject();
for (int i = 0; i < retrieveDataCommandReader.FieldCount; i++)
{
item[retrieveDataCommandReader.GetName(i)] = new JValue(retrieveDataCommandReader.GetValue(i));
}
}
//Foreach river that wants this type of record. Send it.
foreach (var riverRequired in _riverConfiguration.Rivers.Cast<RiverElement>().Where(x => x.DatabaseTable == riverMessage.DatabaseTable))
{
if (item != null)
searchClient.Index(riverRequired.ElasticIndex, riverRequired.ElasticType, riverMessage.Id.ToString(), item.ToString());
else
searchClient.Delete(riverRequired.ElasticIndex, riverRequired.ElasticType, riverMessage.Id.ToString());
}
}
}
}
}
public void AliasesWithDashesAreNotStripped()
{
//unique indexaname already contains dasshes but lets be sure about this
//if the implementation ever changes
var index = ElasticsearchConfiguration.NewUniqueIndexName() + "-dashes";
var x = this.Client.CreateIndex(index);
x.Acknowledged.Should().BeTrue();
var alias = ElasticsearchConfiguration.NewUniqueIndexName() + "-dashed-alias";
var aliasResult = this.Client.Alias(a => a.Add(aa => aa.Index(index).Alias(alias)));
aliasResult.IsValid.Should().BeTrue();
aliasResult.Acknowledged.Should().BeTrue();
var getIndicesResult = Client.GetIndicesPointingToAlias(alias);
getIndicesResult.Should().NotBeEmpty();
var indexReturned = getIndicesResult.First();
indexReturned.Should().Be(index).And.Contain("-dashes");
var getAliasesResult = this.Client.GetAliasesPointingToIndex(index);
getAliasesResult.Should().NotBeEmpty().And.HaveCount(1);
var aliasReturned = getAliasesResult.First().Name;
aliasReturned.Should().Be(alias).And.Contain("-dashed-alias");
var elasticsearchClient = new ElasticsearchClient(ElasticsearchConfiguration.Settings());
var dynamicResult = elasticsearchClient.IndicesGetAlias(index);
IDictionary<string, object> aliases = dynamicResult.Response[index].aliases;
aliases.Count.Should().Be(1);
var aliasDynamic = aliases.Keys.First();
aliasDynamic.Should().Be(alias);
}
/**
* This however is still a non-failover connection. Meaning if that `node` goes down the operation will not be retried on any other nodes in the cluster.
*
* To get a failover connection we have to pass an `IConnectionPool` instance instead of a `Uri`.
*/
public void InstantiatingAConnectionPoolClient()
{
var node = new Uri("http://mynode.example.com:8082/apiKey");
var connectionPool = new SniffingConnectionPool(new[] { node });
var config = new ConnectionConfiguration(connectionPool);
var client = new ElasticsearchClient(config);
}
public async Task<string> SearchAllAsync(string query, int @from, int size)
{
var client = new ElasticsearchClient(_settings);
var queryString = "{\"from\" : " + from + ", \"size\" : " + size + ", \"query\":{\"match\": {\"name\": {\"query\": \" " + query + " \",\"operator\": \"and\"}}}}";
var res = await client.SearchAsync<string>(Setting.ElasticSearchIndex,queryString);
return res.Response;
}
public void Ping_should_work()
{
var settings = new ConnectionConfiguration(new Uri(TestConfig.Endpoint));
var client = new ElasticsearchClient(settings, new AwsHttpConnection(settings, TestConfig.AwsSettings));
var response = client.Ping();
Assert.AreEqual(200, response.HttpStatusCode.GetValueOrDefault(-1));
}
public async Task<string> SearchIngredientsAsync(string query, int @from, int size)
{
var client = new ElasticsearchClient(_settings);
var queryString = "{\"from\": " + from +", \"size\": " + size +", \"filter\": { \"or\": [{\"term\": { \"dataType\": \"hop\"}},{\"term\": {\"dataType\": \"fermentable\"}},{\"term\": {\"dataType\": \"yeast\"}},{\"term\": {\"dataType\": \"other\"}}]},\"query\": {\"match\": {\"name\": {\"query\": \"" + query +"\"}}}}";
var res = await client.SearchAsync<string>(Setting.ElasticSearchIndex, queryString);
return res.Response;
}
public static Response GetItemsByName(string name, string league, int from, int size, ElasticsearchClient client)
{
string query = QueryStringItemByName(name, league, from, size);
var result = client.Search<string>(query);
Response response = new System.Web.Script.Serialization.JavaScriptSerializer().Deserialize<Response>(result.Response);
return response;
}
public SyncLock(ElasticsearchClient client, string index, string type)
{
Client = client;
LockIndex = index;
LockType = type;
Open();
}
private IElasticsearchClient BuildElasticSearchClient(IContext context)
{
Configuration.ISettings settings = context.Kernel.Get<Configuration.ISettings>();
ConnectionConfiguration config = new ConnectionConfiguration(new Uri(settings.ElasticSearch.Host));
ElasticsearchClient client = new ElasticsearchClient(config);
return client;
}
static public ElasticsearchClient Client(string url)
{
var key = url.ToLower();
ElasticsearchClient client;
if (allClients.TryGetValue(key, out client))
return client;
client = new ElasticsearchClient(Create(url));
allClients[key] = client;
return client;
}
public async void Show()
{
var client = new ElasticsearchClient();
var portfolioId = Guid.NewGuid();
await new AsyncElasticsearchProjector(Projection.Handlers).
ProjectAsync(client, new object[]
{
new PortfolioAdded {Id = portfolioId, Name = "My portfolio"},
new PortfolioRenamed {Id = portfolioId, Name = "Your portfolio"},
new PortfolioRemoved {Id = portfolioId}
});
}
public async void Show()
{
//Spin up a docker image of elastic search and/or change the endpoint below
var config = new ConnectionConfiguration(new Uri("http://192.168.99.100:32769/"));
var client = new ElasticsearchClient(config);
var portfolioId = Guid.NewGuid();
await new ConnectedProjector<ElasticsearchClient>(Resolve.WhenEqualToHandlerMessageType(Projection.Handlers)).
ProjectAsync(client, new object[]
{
new PortfolioAdded {Id = portfolioId, Name = "My portfolio"},
new PortfolioRenamed {Id = portfolioId, Name = "Your portfolio"},
new PortfolioRemoved {Id = portfolioId}
});
}
public void IndexWithDashesAreNotStripped2()
{
var index = ElasticsearchConfiguration.NewUniqueIndexName() + "-dashes";
var x = this.Client.CreateIndex(index);
x.Acknowledged.Should().BeTrue();
var alias = ElasticsearchConfiguration.NewUniqueIndexName() + "-dashes-alias";
var aliasResult = this.Client.Alias(a => a.Add(aa => aa.Index(index).Alias(alias)));
aliasResult.IsValid.Should().BeTrue();
aliasResult.Acknowledged.Should().BeTrue();
var elasticsearchClient = new ElasticsearchClient(ElasticsearchConfiguration.Settings());
var dynamicResult = elasticsearchClient.IndicesGetAlias(alias);
dynamicResult.Response.ContainsKey(index).Should().BeTrue();
}
static public bool ShouldAdd(ElasticsearchClient client, ref CandidateFile candidate)
{
var searchQuery = new { query = new { term = new { _id = candidate.AliasedPath } } };
ElasticsearchResponse<string> response;
var timer = new ScopedTimer();
using (timer)
{
response = client.Search<string>(Media.IndexName, JsonConvert.SerializeObject(searchQuery));
}
if (!FirstSearchMsec.HasValue)
{
FirstSearchMsec = timer.TotalMilliseconds;
}
if (!response.Success)
{
response.LogFailure(logger);
return false;
}
candidate.Signature = CalculateSignature(candidate.FullFilename);
candidate.LengthInBytes = new FileInfo(candidate.FullFilename).Length;
var searchResponse = JsonConvert.DeserializeObject<SearchResponse>(response.Response);
// if ((timer.TotalMilliseconds - searchResponse.Took) > 200)
// {
// logger.Warn("Search took {1} milliseconds for: {0}", candidate.AliasedPath, timer.TotalMilliseconds);
// }
// If there's more than one matching path or the signature is different, go through the add process
// If it's not already in the index, add it.
if (searchResponse.Hits.Total != 1)
return true;
var media = searchResponse.Hits.Hits.First().Media;
if (media.Signature != candidate.Signature || media.LengthInBytes != candidate.LengthInBytes)
{
logger.Error("Add {0} due to mis-match ({0}, {1} -- {2}, {3})", candidate.AliasedPath,
media.Signature, media.LengthInBytes,
candidate.Signature, candidate.LengthInBytes);
return true;
}
return false;
}
/// <summary>
/// Connect to ElasticSearch server, before connected all log entries will be catched in queue
/// </summary>
/// <param name="url"></param>
public static void ConnectElasticSearch(string url = "http://localhost:9200/")
{
var node = new Uri(url);
var config = new ConnectionConfiguration(node)
.EnableTrace(false)
.EnableMetrics(false)
.UsePrettyRequests(false)
.UsePrettyResponses(false);
client = new ElasticsearchClient(config);
consoleOnly = false;
CancellationToken ct = stopToken.Token;
Task taskConsumeQueue = Task.Run(() =>
{
while (true)
{
// Bulk insert cached logs every 1 second
while (logEntries.IsEmpty)
{
System.Threading.Thread.Sleep(1000);
// <- Stop()
if (ct.IsCancellationRequested)
{
return;
}
}
int batchLength = 0;
var builder = new StringBuilder();
var timestamp = "logger-" + DateTime.UtcNow.ToString("yyyy-MM-dd");
var indexOp = "{ \"index\" : { \"_index\" : \"" + timestamp + "\", \"_type\" : \"log\" } }";
while (logEntries.IsEmpty == false && batchLength < 100)
{
JObject entry;
if (logEntries.TryDequeue(out entry))
{
builder.AppendLine(indexOp);
builder.AppendLine(entry.ToString(Formatting.None));
batchLength++;
}
}
if (batchLength > 0)
client.BulkAsync(builder.ToString());
}
});
}
public void Calling_A_Null_Field_Should_Not_Throw_With_ElasticsearchNet_Serializer()
{
var client = new ElasticsearchClient();
var result = client.Search("{ size: 10}");
var hit = result.Response["hits"]["hits"][0];
Assert.DoesNotThrow(() => { var x = hit["testfield"]; });
var exists = false;
Assert.DoesNotThrow(() => { exists = hit["testfield"] != null; });
exists.Should().BeFalse();
Assert.DoesNotThrow(() => { exists = hit["_index"] != null; });
exists.Should().BeTrue();
var source = hit["_source"];
((object) source).Should().NotBeNull();
Assert.DoesNotThrow(() => { var x = source["name"]; });
string field = source["name"];
field.Should().NotBeNullOrWhiteSpace();
}
public SyncResponse Exec()
{
var startedOn = DateTime.UtcNow;
log.Info("process started at " + startedOn.NormalizedFormat());
client = new ElasticsearchClient(_config.ElasticSearchConfiguration);
using (var _lock = new SyncLock(client, LogIndex, LockType))
{
DateTime? lastSyncDate = ConfigureIncrementalProcess(_config.SqlCommand, _config.ColumnsToCompareWithLastSyncDate);
var data = GetSerializedObject();
log.Info(String.Format("{0} objects have been serialized.", data.Count()));
var syncResponse = new SyncResponse(startedOn);
syncResponse = IndexProcess(data, syncResponse);
if (_config.DeleteConfiguration != null)
{
_config.SqlConnection.Open();
Dictionary<object, Dictionary<string, object>> deleteData = null;
if (lastSyncDate != null)
ConfigureIncrementalProcess(_config.DeleteConfiguration.SqlCommand, _config.DeleteConfiguration.ColumnsToCompareWithLastSyncDate, lastSyncDate);
using (SqlDataReader rdr = _config.DeleteConfiguration.SqlCommand.ExecuteReader())
{
deleteData = rdr.Serialize();
}
_config.SqlConnection.Close();
syncResponse = DeleteProcess(deleteData, syncResponse);
}
syncResponse = Log(syncResponse);
log.Info(String.Format("process duration: {0}ms", Math.Truncate((syncResponse.EndedOn - syncResponse.StartedOn).TotalMilliseconds)));
return syncResponse;
}
}
public ElasticsearchDestinationWriter(DocumentDatabase database, SqlReplicationConfig _cfg, SqlReplicationStatistics replicationStatistics)
{
var cfg = new ElasticsearchReplicationConfig(_cfg);
this.database = database;
this.cfg = cfg;
this.targetIndexName = cfg.FactoryName.ToLowerInvariant(); // Elasticsearch requires all index names to be lowercased
this.replicationStatistics = replicationStatistics;
try
{
elasticsearchClient = cfg.GetElasticClient();
}
catch (UriFormatException e)
{
if (database != null)
database.AddAlert(new Alert
{
AlertLevel = AlertLevel.Error,
CreatedAt = SystemTime.UtcNow,
Exception = e.ToString(),
Title = "Invalid Elasticsearch URL provided",
Message = "Elasticsearch Replication could not parse one of the provided node URLs",
UniqueKey = "Elasticsearch Replication Connection Error: " + cfg.ConnectionString
});
}
catch (Exception e)
{
if (database != null)
database.AddAlert(new Alert
{
AlertLevel = AlertLevel.Error,
CreatedAt = SystemTime.UtcNow,
Exception = e.ToString(),
Title = "Elasticsearch Replication could not open connection",
Message = "Elasticsearch Replication could not open connection to " + cfg.ConnectionString,
UniqueKey = "Elasticsearch Replication Connection Error: " + cfg.ConnectionString
});
throw;
}
}
private ElasticsearchSinkState(ElasticsearchSinkOptions options)
{
if (string.IsNullOrWhiteSpace(options.IndexFormat)) throw new ArgumentException("options.IndexFormat");
if (string.IsNullOrWhiteSpace(options.TypeName)) throw new ArgumentException("options.TypeName");
if (string.IsNullOrWhiteSpace(options.TemplateName)) throw new ArgumentException("options.TemplateName");
this._templateName = options.TemplateName;
this._templateMatchString = IndexFormatRegex.Replace(options.IndexFormat, @"$1*$2");
_indexDecider = options.IndexDecider ?? ((@event, offset) => string.Format(options.IndexFormat, offset));
_typeName = options.TypeName;
_options = options;
var configuration = new ConnectionConfiguration(options.ConnectionPool)
.SetTimeout(options.ConnectionTimeout)
.SetMaximumAsyncConnections(20);
if (options.ModifyConnectionSetttings != null)
configuration = options.ModifyConnectionSetttings(configuration);
_client = new ElasticsearchClient(configuration, connection: options.Connection, serializer: options.Serializer);
_formatter = options.CustomFormatter ?? new ElasticsearchJsonFormatter(
formatProvider: options.FormatProvider,
renderMessage: true,
closingDelimiter: string.Empty,
serializer: options.Serializer,
inlineFields: options.InlineFields
);
_durableFormatter = options.CustomDurableFormatter ?? new ElasticsearchJsonFormatter(
formatProvider: options.FormatProvider,
renderMessage: true,
closingDelimiter: Environment.NewLine,
serializer: options.Serializer,
inlineFields: options.InlineFields
);
this._registerTemplateOnStartup = options.AutoRegisterTemplate;
}
static public void Add(ElasticsearchClient client, IEnumerable<Media> mediaList)
{
var bulk = new List<string>();
foreach (var media in mediaList)
{
bulk.Add(JsonConvert.SerializeObject(new BulkIndexCommand(Media.IndexName, Media.TypeName, media.Path)));
bulk.Add(JsonConvert.SerializeObject(media, new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() }));
}
var response = client.Bulk<string>(bulk);
if (!response.Success)
{
response.LogFailure(logger, "insert failed");
return;
}
var bulkResponse = JsonConvert.DeserializeObject<BulkResponse>(response.Response);
if (bulkResponse.Errors)
{
logger.Error("At least some inserts failed: {0}", response.Response);
}
}
static void Main(string[] args)
{
var uri = new Uri(URI_STRING);
var settings = new ConnectionConfiguration(uri)
.PrettyJson(true)
.UsePrettyResponses(true);
var client = new ElasticsearchClient(settings);
ItemNamesDataContext itemNamesDB = new ItemNamesDataContext(DATA_CONNETION_STRING);
ItemsDataContext itemsDB = new ItemsDataContext(DATA_CONNETION_STRING);
while (true)
{
// Ordering so we prioritize items that haven't been updated in a while (or ever - so null = yesterday)
foreach (ItemName itemName in itemNamesDB.ItemNames.OrderBy(row => row.LastChecked ?? DateTime.Now.AddDays(-1)))
{
string[] leagues = {
"Standard", "Hardcore", "Warbands", "Tempest"
};
foreach (string league in leagues)
{
int amountOfItems;
int scanned = 0;
List<float> prices = new List<float>();
do
{
Response response;
try
{
response = GetItemsByName(itemName.Name, league, scanned, 200, client);
amountOfItems = response.hits.total;
scanned += response.hits.hits.Count();
foreach (Hit hit in response.hits.hits)
{
prices.Add(hit._source.shop.chaosEquiv);
}
}
catch (System.InvalidOperationException e)
{
// Deserializer found null value -> query resulted empty response
amountOfItems = 0;
}
// Just to monitor status
Console.WriteLine(string.Format("{0} / {1}", scanned, amountOfItems));
// Let's try to not get banned
System.Threading.Thread.Sleep(2000);
} while (scanned < amountOfItems);
prices.Sort();
var entry = new Item
{
Name = itemName.Name,
Amount = amountOfItems,
League = league,
MaxPrice = prices.Any() ? prices.Last() : 0,
MinPrice = prices.Any() ? prices.First() : 0,
MeanPrice = prices.Any() ? prices.Average() : 0,
MedianPrice = prices.Any() ? prices[prices.Count() / 2] : 0,
Timestamp = DateTime.Now
};
itemsDB.Items.InsertOnSubmit(entry);
Console.WriteLine(string.Format("min_price: {0}, max_price: {1}, median: {2}, mean: {3}, item: {4}",
entry.MinPrice, entry.MaxPrice, entry.MedianPrice, entry.MeanPrice, itemName.Name));
}
itemName.LastChecked = DateTime.Now;
try
{
itemNamesDB.SubmitChanges();
itemsDB.SubmitChanges();
}
catch (Exception e)
{
// DB might be busy, or being accessed by someone else and submitting may fail
// It happens only every few hundred submits so I decided to just keep ignore it and continue
continue;
}
}
}
}
public void PostFood(Food food)
{
var ESclient = new ElasticsearchClient();
var response = ESclient.Index<Food>("food", food.Type, food.Id, food);
redDB.StringSet(food.Id, food.Name);
}
/**
* The following is a list of available connection configuration options:
*/
public void AvailableOptions()
{
//hide
var client = new ElasticsearchClient();
//endhide
var config = new ConnectionConfiguration()
.DisableAutomaticProxyDetection()
/** Disable automatic proxy detection. Defaults to true. */
.EnableHttpCompression()
/**
* Enable compressed request and reesponses from Elasticsearch (Note that nodes need to be configured
* to allow this. See the [http module settings](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-http.html) for more info).
*/
.DisableDirectStreaming()
/**
* By default responses are deserialized off stream to the object you tell it to.
* For debugging purposes it can be very useful to keep a copy of the raw response on the result object.
*/;
var result = client.Search<SearchResponse<object>>(new { size = 12 });
var raw = result.ResponseBodyInBytes;
/** This will only have a value if the client configuration has ExposeRawResponse set */
/**
* Please note that this only make sense if you need a mapped response and the raw response at the same time.
* If you need a `string` or `byte[]` response simply call:
*/
var stringResult = client.Search<string>(new { });
//hide
config = config
//endhide
.GlobalQueryStringParameters(new NameValueCollection())
/**
* Allows you to set querystring parameters that have to be added to every request. For instance, if you use a hosted elasticserch provider, and you need need to pass an `apiKey` parameter onto every request.
*/
.Proxy(new Uri("http://myproxy"), "username", "pass")
/** Sets proxy information on the connection. */
.RequestTimeout(TimeSpan.FromSeconds(4))
/**
* Sets the global maximum time a connection may take.
* Please note that this is the request timeout, the builtin .NET `WebRequest` has no way to set connection timeouts
* (see http://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.timeout(v=vs.110).aspx).
*/
.ThrowExceptions()
/**
* As an alternative to the C/go like error checking on `response.IsValid`, you can instead tell the client to throw
* exceptions.
*
* There are three category of exceptions thay may be thrown:
*
* 1) ElasticsearchClientException: These are known exceptions, either an exception that occurred in the request pipeline
* (such as max retries or timeout reached, bad authentication, etc...) or Elasticsearch itself returned an error (could
* not parse the request, bad query, missing field, etc...). If it is an Elasticsearch error, the `ServerError` property
* on the response will contain the the actual error that was returned. The inner exception will always contain the
* root causing exception.
*
* 2) UnexpectedElasticsearchClientException: These are unknown exceptions, for instance a response from Elasticsearch not
* properly deserialized. These are usually bugs and should be reported. This excpetion also inherits from ElasticsearchClientException
* so an additional catch block isn't necessary, but can be helpful in distinguishing between the two.
*
* 3) Development time exceptions: These are CLR exceptions like ArgumentException, NullArgumentException etc... that are thrown
* when an API in the client is misused. These should not be handled as you want to know about them during development.
*
*/
.PrettyJson()
/**
* Forces all serialization to be indented and appends `pretty=true` to all the requests so that the responses are indented as well
*/
.BasicAuthentication("username", "password")
/** Sets the HTTP basic authentication credentials to specify with all requests. */;
/**
* **Note:** This can alternatively be specified on the node URI directly:
*/
var uri = new Uri("http://*****:*****@localhost:9200");
var settings = new ConnectionConfiguration(uri);
/**
* ...but may become tedious when using connection pooling with multiple nodes.
*/
}
public async Task SearchAllElasticSearch()
{
var node = new Uri("http://localhost:9200");
var settings = new ConnectionConfiguration(node);
var client = new ElasticsearchClient(settings);
var query = "{\"query\" : { \"term\": { \"name\" : \"safale\"}}}";
var res = client.Search<string>(Setting.ElasticSearchIndex, query);
dynamic json = JsonConvert.DeserializeObject(res.Response);
var result = json.hits.hits;
}
/**
* If your Elasticsearch node does not live at `http://localhost:9200` but i.e `http://mynode.example.com:8082/apiKey`, then
* you will need to pass in some instance of `IConnectionConfigurationValues`.
*
* The easiest way to do this is:
*/
public void InstantiatingASingleNodeClient()
{
var node = new Uri("http://mynode.example.com:8082/apiKey");
var config = new ConnectionConfiguration(node);
var client = new ElasticsearchClient(config);
}
/** # Connecting
* Connecting to *Elasticsearch* with `Elasticsearch.Net` is quite easy but has a few toggles and options worth knowing.
*
* # Choosing the right connection strategy
* If you simply new an `ElasticsearchClient`, it will be a non-failover connection to `http://localhost:9200`
*/
public void InstantiateUsingAllDefaults()
{
var client = new ElasticsearchClient();
var tokenizers = new TokenizersDescriptor();
}
public IndexMediaQueue(Func<bool> dependencyIsActive, int numTasks, string serverUrl, Action<int> itemsIndexed)
: base(dependencyIsActive, numTasks)
{
this.itemsIndexed = itemsIndexed;
this.client = FindAPhotoConnectionSettings.Client(serverUrl);
}
/**
* The following is a list of available connection configuration options:
*/
public void AvailableOptions()
{
//hide
var client = new ElasticsearchClient();
//endhide
var config = new ConnectionConfiguration()
.DisableAutomaticProxyDetection()
/** Disable automatic proxy detection. Defaults to true. */
.EnableHttpCompression()
/**
* Enable compressed request and reesponses from Elasticsearch (Note that nodes need to be configured
* to allow this. See the [http module settings](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-http.html) for more info).
*/
.EnableMetrics()
/** Enable more meta data to be returned per API call about requests (ping, sniff, failover, and general stats). */
.EnableTrace()
/**
* Will cause `Elasticsearch.Net` to write connection debug information on the TRACE output of your application.
*/
.DisableDirectStreaming()
/**
* By default responses are deserialized off stream to the object you tell it to.
* For debugging purposes it can be very useful to keep a copy of the raw response on the result object.
*/;
var result = client.Search<SearchResponse<object>>(new { size = 12 });
var raw = result.ResponseBodyInBytes;
/** This will only have a value if the client configuration has ExposeRawResponse set */
/**
* Please note that this only make sense if you need a mapped response and the raw response at the same time.
* If you need a `string` or `byte[]` response simply call:
*/
var stringResult = client.Search<string>(new { });
//hide
config = config
//endhide
.SetConnectionStatusHandler(s => { })
/**
* Allows you to pass a `Action<IElasticsearchResponse>` that can eaves drop every time a response (good or bad) is created. If you have complex logging needs
* this is a good place to add that in.
*/
.SetGlobalQueryStringParameters(new NameValueCollection())
/**
* Allows you to set querystring parameters that have to be added to every request. For instance, if you use a hosted elasticserch provider, and you need need to pass an `apiKey` parameter onto every request.
*/
.SetProxy(new Uri("http://myproxy"), "username", "pass")
/** Sets proxy information on the connection. */
.RequestTimeout(TimeSpan.FromSeconds(4))
/**
* Sets the global maximum time a connection may take.
* Please note that this is the request timeout, the builtin .NET `WebRequest` has no way to set connection timeouts
* (see http://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.timeout(v=vs.110).aspx).
*/
//TODO document this properly once we figure out exceptions
.ThrowExceptions()
/**
* As an alternative to the C/go like error checking on `response.IsValid`, you can instead tell the client to always throw
* an `ElasticsearchServerException` when a call resulted in an exception on the Elasticsearch server. Reasons for
* such exceptions could be search parser errors and index missing exceptions.
*/
.PrettyJson()
/**
* Forces all serialization to be indedented and appends `pretty=true` to all the requests so that the responses are indented as well
*/
.SetBasicAuthentication("username", "password")
/** Sets the HTTP basic authentication credentials to specify with all requests. */;
/**
* **Note:** This can alternatively be specified on the node URI directly:
*/
var uri = new Uri("http://*****:*****@localhost:9200");
var settings = new ConnectionConfiguration(uri);
/**
* ...but may become tedious when using connection pooling with multiple nodes.
*/
}
public void GetServerHealth()
{
var client = new ElasticsearchClient();
var result = client.CatHealth(param => param.V(true));
Assert.IsNotNull(result);
}
public void GetIndicesStatus()
{
var client = new ElasticsearchClient();
var result = client.CatIndices(param => param.V(true));
Assert.IsNotNull(result);
}
public static Task <ElasticsearchResponse <T> > IndicesPutAliasAsync <T>(this ElasticsearchClient client, string index, string name, object body, Func <IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
{
var selector = Obsolete.UpCastSelector <IndicesPutAliasRequestParameters, PutAliasRequestParameters>(requestParameters);
return(client.IndicesPutAliasAsync <T>(index, name, selector));
}
