public Elastic(string index_path) { try { var line = File.ReadLines(index_path); indexname = line.First().Trim(); } catch (IOException e) { Console.WriteLine("Error reading " + index_path); System.Environment.Exit(-1); } string user = "******"; string password = "******"; uri = "http://10.4.3.188:9200"; var config = new ConnectionConfiguration(new Uri(uri)).BasicAuthentication(user, password); client = new ElasticLowLevelClient(config); Console.WriteLine("Connecting to ElasticSearch..."); var response = client.Cat.Health <StringResponse>(); if (response.HttpStatusCode != 200) { System.Environment.Exit(-1); } Console.WriteLine("OK", Console.ForegroundColor = ConsoleColor.Green); Console.ResetColor(); }
public void con() { var settings = new ConnectionConfiguration(new Uri("http://localhost:9200")) .RequestTimeout(TimeSpan.FromMinutes(2)); var connection = new ElasticLowLevelClient(settings); var searchResponse = connection.Search <StringResponse>("test", PostData.Serializable(new { from = 0, size = 10, query = new { match = new { nombre = new { query = "Yesid2" } } } })); var successful = searchResponse.Success; var responseJson = searchResponse.Body; Console.WriteLine(responseJson); }
public bool CreateIndex(IIndexCreateRequest request) { // TODO Validation if (request is null) { Logger.LogError("Definition is invalid"); throw new ArgumentException("Argument \"definition\" is null or not of type ElasticIndexDefinition"); } var node = new Uri(request.IndexerEndpoint); var fileText = System.IO.File.ReadAllText(request.IndexDefinitionFilePath); var settings = new ConnectionSettings(node); var postData = PostData.String(fileText); var client = new ElasticLowLevelClient(settings); var response = client.DoRequest <StringResponse>(HttpMethod.PUT, request.IndexName, postData); if (response.HttpStatusCode.HasValue) { // TODO Good or bad? Logger.LogInformation($"StatusCode {response.HttpStatusCode}"); } Logger.LogDebug(response.DebugInformation); Logger.LogInformation(response.Body); return(response.Success); }
public override void Dispose() { if (initialised) { client = null; } }
/** * Often you may need to pass additional configuration options to the client such as the address of Elasticsearch if it's running on * a remote machine. This is where `ConnectionConfiguration` comes in; an instance can be instantiated to provide * the client with different configuration values. */ public void UsingConnectionSettings() { var settings = new ConnectionConfiguration(new Uri("http://example.com:9200")) .RequestTimeout(TimeSpan.FromMinutes(2)); var lowlevelClient = new ElasticLowLevelClient(settings); }
/** * This will still be 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 <<connection-pooling, 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 ElasticLowLevelClient(config); }
public JsonResult Delete(int id) { var oResult = new Object(); try { var settings = new ConnectionConfiguration(new Uri("http://localhost:9200/")) .RequestTimeout(TimeSpan.FromMinutes(2)); var lowlevelClient = new ElasticLowLevelClient(settings); var searchResponse = lowlevelClient.Delete <string>("user", "guest", id.ToString()); bool successful = searchResponse.Success; oResult = new { Bresult = successful, Notice = successful ? "删除成功!" : "删除失败!" }; var responseJson = searchResponse.Body; return(Json(oResult, JsonRequestBehavior.AllowGet)); } catch (Exception ex) { oResult = new { Bresult = false, Notice = String.Format("删除失败!异常:{0}", ex.Message) }; return(Json(oResult, JsonRequestBehavior.AllowGet)); } }
public async Task OpenAsync(string correlationId) { if (IsOpened()) { return; } var connection = await _connectionResolver.ResolveAsync(correlationId); var uri = new Uri(connection.Uri); try { // Create client var settings = new ConnectionConfiguration(uri) .RequestTimeout(TimeSpan.FromMinutes(2)) .ThrowExceptions(true); _client = new ElasticLowLevelClient(settings); // Create index if it doesn't exist await CreateIndex(correlationId, true); if (_timer == null) { _timer = new FixedRateTimer(OnTimer, _interval, _interval); _timer.Start(); } } catch { // Do nothing if elastic search client was not initialized _errorConsoleLogger.Error(correlationId, $"Failed to initialize Elastic Search Logger with uri='{uri}'"); } }
static Program() { //创建es连接 var settings = new ConnectionConfiguration(new Uri("http://192.168.1.40:9200")).RequestTimeout(TimeSpan.FromMinutes(2)); client = new ElasticLowLevelClient(settings); }
public void SendLogEventsToAirlock_GotItAtElastic() { const int eventCount = 10; var log = IntegrationTestsEnvironment.Log; var logEvents = GenerateLogEvens(eventCount); PushToAirlock(logEvents); var connectionPool = new StickyConnectionPool(new[] { new Uri("http://localhost:9200") }); var elasticConfig = new ConnectionConfiguration(connectionPool, cfg => { cfg.EnableDebugMode(); return(null); }); var elasticClient = new ElasticLowLevelClient(elasticConfig); var indexName = $"{IntegrationTestsEnvironment.Project}-{IntegrationTestsEnvironment.Environment}-{logEvents.First().Timestamp:yyyy.MM.dd}"; var testId = logEvents.First().Properties["testId"]; var expectedLogMessages = new HashSet <string>(logEvents.Select(x => x.Message)); WaitHelper.WaitSafe( () => { var elasticsearchResponse = elasticClient.Search <string>( indexName, "LogEvent", new { from = 0, size = eventCount, query = new { match = new { testId, } } }); log.Debug(elasticsearchResponse.DebugInformation); if (!elasticsearchResponse.Success) { log.Error(elasticsearchResponse.OriginalException); return(WaitAction.ContinueWaiting); } var hits = (JArray)((dynamic)JObject.Parse(elasticsearchResponse.Body)).hits.hits; if (expectedLogMessages.Count != hits.Count) { log.Error($"Invalid event count: {hits.Count}, expected: {expectedLogMessages.Count}"); return(WaitAction.ContinueWaiting); } foreach (dynamic hit in hits) { string message = hit._source.Message; Assert.True(expectedLogMessages.Contains(message)); } return(WaitAction.StopWaiting); }); }
public ElasticIndexer(ElasticSearchSettings settings) { string uri = settings.Uri; Uri = new Uri("https://" + uri); Client = LoadClient(); }
public ElasticSearchDriver(ILogger <ElasticSearchDriver> logger, Uri uri, string index) { IndexName = index; Logger = logger; var connectionSettings = new ConnectionSettings(uri) .DefaultIndex(index) .ThrowExceptions(); lowLevelClient = new ElasticLowLevelClient(connectionSettings); client = new ElasticClient(connectionSettings); if (!ExtantIndicies.Contains(index)) { lock (ExtantIndicies) { var exists = client.IndexExists(index); if (!exists.Exists) { Logger.LogInformation("Index does not exist, creating it now"); var descriptor = new CreateIndexDescriptor(index) .Mappings(ms => ms .Map <Document>(m => m.AutoMap()) ); var response = client.CreateIndex(descriptor); } ExtantIndicies.Add(index); } } }
public void CheckSessionIndexIsDeleted() { string indexAndTypeName = $"index_{Guid.NewGuid().ToString()}"; var mapping = @"{""properties"": {""message"": {""type"": ""string"", ""store"": true}}}"; var documents = @"[{""message"": ""The quick brown fox jumps over the lazy dog""}]"; var esUri = new Uri("http://localhost:9200"); var config = new ConnectionConfiguration(esUri); var esClient = new ElasticLowLevelClient(config); var uniqueNameResolverMock = new Mock <IUniqueNameResolver>(); uniqueNameResolverMock.Setup(r => r.GetUniqueName()).Returns(indexAndTypeName); var idGeneratorMock = new Mock <IIdGenerator>(); idGeneratorMock.Setup(g => g.NextId()).Returns(1); var validator = new EsfStateInputValidator(); using (var session = new Domain.ElasticsearchSession(esClient, uniqueNameResolverMock.Object, idGeneratorMock.Object, validator)) { session.CreateMapping(mapping); session.InsertDocuments(documents); var indexExistsResponse = esClient.IndicesGet <string>(indexAndTypeName); Assert.True(indexExistsResponse.Success); } var indexExistsResponse2 = esClient.IndicesGet <string>(indexAndTypeName); Assert.False(indexExistsResponse2.Success); }
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"); } _templateName = options.TemplateName; _templateMatchString = IndexFormatRegex.Replace(options.IndexFormat, @"$1*$2"); _indexDecider = options.IndexDecider ?? ((@event, offset) => string.Format(options.IndexFormat, offset)); _options = options; Func <ConnectionConfiguration, IElasticsearchSerializer> serializerFactory = null; if (options.Serializer != null) { serializerFactory = s => options.Serializer; } var configuration = new ConnectionConfiguration(options.ConnectionPool, options.Connection, serializerFactory) .RequestTimeout(options.ConnectionTimeout); if (options.ModifyConnectionSettings != null) { configuration = options.ModifyConnectionSettings(configuration); } configuration.ThrowExceptions(); _client = new ElasticLowLevelClient(configuration); _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 ); _registerTemplateOnStartup = options.AutoRegisterTemplate; TemplateRegistrationSuccess = !_registerTemplateOnStartup; }
public void TestReadPage() { var connection = new Connection { Name = "input", Provider = "elasticsearch", Index = "colors", Server = "localhost", Port = 9200 }.WithValidation(); connection.Url = connection.BuildElasticUrl(); var pool = new SingleNodeConnectionPool(new Uri(connection.Url)); var settings = new ConnectionConfiguration(pool); var client = new ElasticLowLevelClient(settings); var context = new ConnectionContext(new PipelineContext(new TraceLogger(), null, new Entity { Name = "rows", Alias = "rows", Page = 2, PageSize = 20 }.WithDefaults()), connection); var code = new Field { Name = "code", Index = 0 }.WithDefaults(); var total = new Field { Name = "total", Type = "int", Index = 1 }.WithDefaults(); var reader = new ElasticReader(context, new[] { code, total }, client, new RowFactory(2, false, false), ReadFrom.Input); var rows = reader.Read().ToArray(); Assert.AreEqual(20, rows.Length); }
public ElasticsearchService(IOptionsMonitor <ElasticsearchOptions> options , ILoggerFactory loggerFac) { _elasticsearchOptions = options.CurrentValue; options.OnChange((elasticsearchOpt, s) => { _elasticsearchOptions = elasticsearchOpt; System.Diagnostics.Debug .WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(elasticsearchOpt) + "---" + s); }); var lowlevelClient = new ElasticLowLevelClient(); var urlColl = new Uri[_elasticsearchOptions.Host.Length]; for (int i = 0; i < _elasticsearchOptions.Host.Length; i++) { urlColl[i] = new Uri(_elasticsearchOptions.Host[i]); } _loggerFac = loggerFac; var connectionPool = new SniffingConnectionPool(urlColl); var settings = new ConnectionSettings(connectionPool) .RequestTimeout(TimeSpan.FromMinutes(_elasticsearchOptions.TimeOut)) .DefaultIndex("mylogjob"); _elasticClient = new ElasticClient(settings); }
/// <summary> /// Main /// </summary> /// <param name="args">参数</param> static void Main(string[] args) { var settings = new ConnectionConfiguration(new Uri("http://localhost:9200")) .RequestTimeout(TimeSpan.FromMinutes(2)); var client = new ElasticLowLevelClient(settings); //新增一个人 /* * var person = new Person { * FirstName = "Martign", * LastName = "Laarman" * }; * var indexResponse = client.Index<BytesResponse>("people", "person", "1", PostData.Serializable(person)); * var responseBytes = indexResponse.Body; */ //批量新增 var persons = new object[] { new { index = new { _index = "people", _type = "person", _id = "2" } }, new { FirstName = "Russ", LastName = "Cam" }, new { index = new { _index = "people", _type = "person", _id = "3" } }, new { FirstName = "Rose", LastName = "Cam" }, new { index = new { _index = "people", _type = "person", _id = "4" } }, new { FirstName = "Malilian", LastName = "Menluo" } }; var bulkResponse = client.Bulk <StringResponse>(PostData.MultiJson(persons)); var responseStream = bulkResponse.Body; }
private void cmdSearch_Click(object sender, EventArgs e) { var settings = new ConnectionConfiguration(EndPoint()) //.ThrowExceptions() .RequestTimeout(TimeSpan.FromMinutes(2)); var lowlevelClient = new ElasticLowLevelClient(settings); var searchResponse = lowlevelClient.Search <StringResponse>("people", "person", PostData.Serializable(new { size = 10, query = new { match = new { firstName = new { query = "David" } } } })); var successful = searchResponse.Success; var responseJson = searchResponse.Body; var successOrKnownError = searchResponse.SuccessOrKnownError; var exception = searchResponse.OriginalException; txtResult.Text = PrettyPrintJSON(responseJson); }
private void cmdInsert_Click(object sender, EventArgs e) { var settings = new ConnectionConfiguration(EndPoint()) .RequestTimeout(TimeSpan.FromMinutes(2)); var lowlevelClient = new ElasticLowLevelClient(settings); var person = new Person { firstName = "David", lastName = "Betteridge" }; var indexResponse = lowlevelClient.Index <BytesResponse>("people", "person", "David", PostData.Serializable(person)); var responseBytes = indexResponse.Body; txtResult.Text = PrettyPrintJSON(BytesToString(responseBytes)); /************************************************************************************************ * We can also get the result in string format \/ *************************************************************************************************/ //var indexResponse = lowlevelClient.Index<StringResponse>("people", "person", "David", PostData.Serializable(person)); //var responseString = indexResponse.Body; //txtResult.Text = PrettyPrintJSON(responseString); }
/** * Using these details, it is possible to make decisions around what should be done in your application. * * The default behaviour of not throwing exceptions can be changed by setting `.ThrowExceptions()` on `ConnectionConfiguration` */ public void HandlingErrors() { var settings = new ConnectionConfiguration(new Uri("http://example.com:9200")) .ThrowExceptions(); var lowlevelClient = new ElasticLowLevelClient(settings); }
} //Singleton pattern private ElasticTelemetry() { try { //Load custom app.config for this assembly var appConfig = ConfigurationManager.OpenExeConfiguration(Assembly.GetExecutingAssembly().Location); //Configure connection settings var connectionSettings = new ConnectionConfiguration(new Uri(appConfig.AppSettings.Settings["ElasticServer"].Value)); connectionSettings .BasicAuthentication(appConfig.AppSettings.Settings["ElasticUser"].Value, appConfig.AppSettings.Settings["ElasticPassword"].Value) .RequestTimeout(TimeSpan.FromSeconds(30)) .DisableDirectStreaming(); //Create Elastic client _ElasticClient = new ElasticLowLevelClient(connectionSettings); //Set Elastic Index and Type _ElasticIndex = appConfig.AppSettings.Settings["ElasticIndex"].Value; _ElasticType = appConfig.AppSettings.Settings["ElasticType"].Value; } catch (Exception e) { logger.Fatal(e); } }
/**[[configuration-options]] * === Configuration options * * Connecting to Elasticsearch with <<elasticsearch-net-getting-started,Elasticsearch.Net>> and <<nest-getting-started,NEST>> is easy, but * it's entirely possible that you'd like to change the default connection behaviour. There are a number of configuration options available * on `ConnectionSettings` (and `ConnectionConfiguration` for Elasticsearch.Net) that can be used to control * how the clients interact with Elasticsearch. * * ==== Options on ConnectionConfiguration * * The following is a list of available connection configuration options on `ConnectionConfiguration`; since * `ConnectionSettings` derives from `ConnectionConfiguration`, these options are available for both * Elasticsearch.Net and NEST: * * :xml-docs: Elasticsearch.Net:ConnectionConfiguration`1 * * ==== Options on ConnectionSettings * * The following is a list of available connection configuration options on `ConnectionSettings`: * * :xml-docs: Nest:ConnectionSettingsBase`1 * * Here's an example to demonstrate setting several configuration options using the low level client */ public void AvailableOptions() { var connectionConfiguration = new ConnectionConfiguration() .DisableAutomaticProxyDetection() .EnableHttpCompression() .DisableDirectStreaming() .PrettyJson() .RequestTimeout(TimeSpan.FromMinutes(2)); var lowLevelClient = new ElasticLowLevelClient(connectionConfiguration); /** * And with the high level client */ var connectionSettings = new ConnectionSettings() .DefaultMappingFor <Project>(i => i .IndexName("my-projects") .TypeName("project") ) .EnableDebugMode() .PrettyJson() .RequestTimeout(TimeSpan.FromMinutes(2)); var client = new ElasticClient(connectionSettings); /**[NOTE] * ==== * * Basic Authentication credentials can alternatively be specified on the node URI directly */ var uri = new Uri("http://*****:*****@localhost:9200"); var settings = new ConnectionConfiguration(uri); }
public void Initialize(string configFilepath, bool isTestMode, SimpleSettings settings, IDataRepository dataManager) { try { if (!File.Exists(configFilepath)) { throw new FileNotFoundException($"{configFilepath} was not found"); } XDocument xDocument = XDocument.Load(configFilepath); var elkurl = xDocument.Element("ELKUrl")?.Value; _elasticClient = new ElasticClient(new Uri(elkurl)); _elasticLowLevelClient = new ElasticLowLevelClient( new ConnectionConfiguration(new SniffingConnectionPool(new List <Uri>() { new Uri(elkurl) }))); _indexPath = new List <string>(); _addDocumentQueue = new ConcurrentBag <object[]>(); Task.Factory.StartNew(new Action(UpdateNodeRun)); } catch (Exception e) { Logger.Error(e, "Initialize"); } }
public ElasticSearchConnection() { var settings = new ConnectionConfiguration(new Uri("http://localhost:9200")) .RequestTimeout(TimeSpan.FromMinutes(2)); this.client = new ElasticLowLevelClient(settings); }
public void VerifyingEverythingInElasticsearch(int age, int isOver50) { const string message = "isOver50 != searchResults.Documents.Count"; var uri = new Uri(_elasticConfig.Uri); var settings = new ConnectionSettings(uri).DefaultIndex(_elasticConfig.Index); var elasticLowLevelClient = new ElasticLowLevelClient(settings); var client = new ElasticClient(settings); int tries = 60; while (tries-- > 0) { var searchResults = client.Search <IncidentReport>(s => s .From(0) .Size(500) .Query(q => q.Term(p => p.ReportedBy.Age, age))); try { Assert.AreEqual(isOver50, searchResults.Documents.Count, message); return; } catch (Exception exception) { _logger.Warning(exception, message); } Thread.Sleep(TimeSpan.FromSeconds(1)); } throw new Exception("isOver50 != searchResults.Documents.Count"); }
//General - Set the settings for this project private void setSettings(AppSettings settings) { appSettings = settings; database = new LLDatabase(appSettings.elasticip, appSettings.defaultIndex); if (database.isValid()) { bottomDBStatusText.Text = "Connected"; client = database.getClient(); if (queryBuilder == null) { queryBuilder = new LLQueryBuilder(client); } else { queryBuilder.setClient(client); } queryBuilder.setMainIndex(appSettings.defaultIndex); queryBuilder.setFileExclusions(appSettings.exclusions); enableComponents(); } else { bottomDBStatusText.Text = "No connection"; MessageBox.Show("Connection failed! Check your settings..."); logger.debug("setSettings failed! -> elastic ip: " + appSettings.elasticip + " elastic index" + appSettings.defaultIndex); } }
public void Call_to_Elasticsearch_propagates_Trace_Context_when_HttpDiagnosticsSubscriber_subscribed() { using var localServer = LocalServer.Create(context => { var traceparent = context.Request.Headers.Get("traceparent"); traceparent.Should().NotBeNullOrEmpty(); var elasticTraceparent = context.Request.Headers.Get("elastic-apm-traceparent"); elasticTraceparent.Should().NotBeNullOrEmpty().And.Be(traceparent); var tracestate = context.Request.Headers.Get("tracestate"); tracestate.Should().NotBeNullOrEmpty().And.Contain("es=s:1"); context.Response.StatusCode = 200; }); using var agent = new ApmAgent(new TestAgentComponents(payloadSender: new MockPayloadSender(), configuration: new MockConfiguration(exitSpanMinDuration: "0", spanCompressionEnabled: "false"))); using var subscribe = agent.Subscribe(new ElasticsearchDiagnosticsSubscriber(), new HttpDiagnosticsSubscriber()); var client = new ElasticLowLevelClient(new ConnectionConfiguration(new Uri(localServer.Uri))); agent.Tracer.CaptureTransaction("Transaction", ApiConstants.TypeDb, t => { var response = client.Cat.Indices <StringResponse>(); }); }
protected ServerErrorTestsBase() { var settings = FixedResponseClient.CreateConnectionSettings(ResponseJson, 500); LowLevelClient = new ElasticLowLevelClient(settings); HighLevelClient = new ElasticClient(settings); }
public static void execute(string host, int port, Dictionary <ulong, FileNameAndParentFrn> files, int chunkSize = 10000) { var settings = new ConnectionConfiguration(new Uri("http://" + host + ":" + port)) .RequestTimeout(TimeSpan.FromMinutes(2)); var lowlevelClient = new ElasticLowLevelClient(settings); var index = DateTime.Now.ToString("yyyyMMddHHmmss"); var type = "pathes"; long id = 1; foreach (var chank in files.Values.Chunks(chunkSize)) { var json = new List <object>(); foreach (var file in chank) { json.Add(new Index(id, index, type)); json.Add(new FileEntry(file.Path, "")); id++; } var indexResponse = lowlevelClient.Bulk <StreamResponse>(PostData.MultiJson(json)); using (var responseStream = indexResponse.Body) { Console.Write("."); } } Console.WriteLine(""); }
/// <summary> /// Returns a new instance of ElasticLowLevelClient configured /// with DataSetFetcher instance settings /// </summary> /// <returns></returns> protected ElasticLowLevelClient getClient() { var conf = new ConnectionConfiguration(ClusterUri); var client = new ElasticLowLevelClient(conf); return(client); }
public static void MainMethod() { try { //var lowlevelClient = new ElasticLowLevelClient(); var settings = new ConnectionConfiguration(new Uri("http://120.27.213.67:9200")).RequestTimeout(TimeSpan.FromMinutes(2)); //var lowlevelClient = new ElasticLowLevelClient(settings); //var uris = new[]{new Uri("http://120.27.213.67:9200"),}; //var connectionPool = new SniffingConnectionPool(uris); //var settings = new ConnectionConfiguration(connectionPool); var lowlevelClient = new ElasticLowLevelClient(settings); var person = new Person { FirstName = "Martijn", LastName = "Laarman" }; var indexResponse = lowlevelClient.Index <StringResponse>("people", "person", "1", PostData.Serializable(person)); string responseBytes = indexResponse.Body; //var asyncIndexResponse = await lowlevelClient.IndexAsync<StringResponse>("people", "person", "1", PostData.Serializable(person)); //string responseString = asyncIndexResponse.Body; } catch (Exception ex) { throw ex; } }
public void Ping_should_work() { var httpConnection = new AwsHttpConnection(TestConfig.AwsSettings); var pool = new SingleNodeConnectionPool(new Uri(TestConfig.Endpoint)); var config = new ConnectionConfiguration(pool, httpConnection); var client = new ElasticLowLevelClient(config); var response = client.Ping<object>(); Assert.AreEqual(200, response.HttpStatusCode.GetValueOrDefault(-1)); }
public void Asterisk_encoded_url_should_work() { var httpConnection = new AwsHttpConnection(TestConfig.AwsSettings); var pool = new SingleNodeConnectionPool(new Uri(TestConfig.Endpoint)); var config = new ConnectionConfiguration(pool, httpConnection); var client = new ElasticLowLevelClient(config); var response = client.Get<Stream>("index*", "type", "id"); Assert.AreEqual(404, response.HttpStatusCode.GetValueOrDefault(-1)); }
public void Random_encoded_url_should_work() { var randomString = Guid.NewGuid().ToString("N"); var httpConnection = new AwsHttpConnection(TestConfig.AwsSettings); var pool = new SingleNodeConnectionPool(new Uri(TestConfig.Endpoint)); var config = new ConnectionConfiguration(pool, httpConnection); var client = new ElasticLowLevelClient(config); var response = client.Get<Stream>(randomString, string.Join(",", Enumerable.Repeat(randomString, 2)), randomString); Assert.AreEqual(404, response.HttpStatusCode.GetValueOrDefault(-1)); }
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; Func<ConnectionConfiguration, IElasticsearchSerializer> serializerFactory = null; if (options.Serializer != null) { serializerFactory = s => options.Serializer; } ConnectionConfiguration configuration = new ConnectionConfiguration(options.ConnectionPool, options.Connection, serializerFactory) .RequestTimeout(options.ConnectionTimeout); if (options.ModifyConnectionSettings != null) configuration = options.ModifyConnectionSettings(configuration); configuration.ThrowExceptions(); _client = new ElasticLowLevelClient(configuration); _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 ); _registerTemplateOnStartup = options.AutoRegisterTemplate; }
private static List<Tuple<string, string, string, DateTime>> HierarchySearch() { var node = new Uri("http://boom-box-1.boomerang.com:9200"); var config = new ConnectionConfiguration(node); var client = new ElasticLowLevelClient(config); var result = client.SearchGet<object>("hsbc_conform", "osf_hierarchies", (arg) => arg.AddQueryString("size", "100")); var root = JObject.FromObject(result.Body); var hierarchies = new List<Tuple<string, string, string, DateTime>>(); foreach (var item in root["hits"]["hits"]) { var date = item["_source"]["ctl"]["effective_date"].Value<string>(); var country = item["_source"]["conform"]["geography"].Value<string>(); var channel = item["_source"]["conform"]["channel"].Value<string>(); var parsedDate = DateTime.ParseExact(date, "yyyyMMdd", CultureInfo.InvariantCulture); var tuple = Tuple.Create(channel, country, date, parsedDate); hierarchies.Add(tuple); } return hierarchies; }
/**== Connecting * Connecting to Elasticsearch with `Elasticsearch.Net` is quite easy and there a few options to suit a number of different use cases. * * [[connection-strategies]] * === Choosing the right Connection Strategy * If you simply new an `ElasticLowLevelClient`, it will be a non-failover connection to `http://localhost:9200` */ public void InstantiateUsingAllDefaults() { var client = new ElasticLowLevelClient(); }
/** * If your Elasticsearch node does not live at `http://localhost:9200` but instead lives somewhere else, for example, `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 ElasticLowLevelClient(config); }
/** * The following is a list of available connection configuration options: */ public void AvailableOptions() { var config = new ConnectionConfiguration() .DisableAutomaticProxyDetection() // <1> Disable automatic proxy detection. When called, defaults to `true`. .EnableHttpCompression() // <2> Enable compressed request and responses from Elasticsearch (Note that nodes need to be configured to allow this. See the {ref_current}/modules-http.html[http module settings] for more info). .DisableDirectStreaming(); // <3> By default responses are deserialized directly from the response 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, which is what calling this method will do. var client = new ElasticLowLevelClient(config); var result = client.Search<SearchResponse<object>>(new { size = 12 }); /** `.ResponseBodyInBytes` will only have a value if the client configuration has `DisableDirectStreaming` set */ var raw = result.ResponseBodyInBytes; /** * Please note that using `.DisableDirectStreaming` only makes sense if you need the mapped response **and** the raw response __at the same time__. * If you need only a `string` response simply call */ var stringResult = client.Search<string>(new { }); /** * and similarly, if you need only a `byte[]` */ var byteResult = client.Search<byte[]>(new { }); /** other configuration options */ config = config .GlobalQueryStringParameters(new NameValueCollection()) // <1> 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") // <2> Sets proxy information on the connection. .RequestTimeout(TimeSpan.FromSeconds(4)) // <3> [[request-timeout]] 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[the MSDN documentation on `HttpWebRequest.Timeout` Property]). .ThrowExceptions() // <4> As an alternative to the C/go like error checking on `response.IsValid`, you can instead tell the client to <<thrown-exceptions, throw exceptions>>. .PrettyJson() // <5> 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"); // <6> sets the HTTP basic authentication credentials to specify with all requests. /** * NOTE: Basic authentication credentials can alternatively be specified on the node URI directly: */ var uri = new Uri("http://*****:*****@localhost:9200"); var settings = new ConnectionConfiguration(uri); /** *...but this may become tedious when using connection pooling with multiple nodes. * * [[thrown-exceptions]] * === Exceptions * There are three categories of exceptions that may be thrown: * * `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. * * `UnexpectedElasticsearchClientException`:: These are unknown exceptions, for instance a response from Elasticsearch not * properly deserialized. These are usually bugs and {github}/issues[should be reported]. This exception also inherits from `ElasticsearchClientException` * so an additional catch block isn't necessary, but can be helpful in distinguishing between the two. * * Development time exceptions:: These are CLR exceptions like `ArgumentException`, `ArgumentOutOfRangeException`, 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. * */ }
/** * The following is a list of available connection configuration options: */ public void AvailableOptions() { //hide var client = new ElasticLowLevelClient(); //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 void SaveObject(Object obj) { Type typeObj = obj.GetType(); if (!System.Configuration.ConfigurationManager.AppSettings["StorageType"].Equals("SQL")) { var node = new Uri(blueChappieSetttings.BlueChappieElasticServer + "/" + typeObj.Name + "lib/"); var config = new ConnectionConfiguration(node); var client = new ElasticLowLevelClient(config); string imgInfo = Newtonsoft.Json.JsonConvert.SerializeObject(obj); PostData<object> postingData = imgInfo; dynamic result0 = client.DoRequest<object>(HttpMethod.PUT, typeObj.Name, postingData); } else { System.Data.DataSet dataSet = new System.Data.DataSet(); System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection("Database=BlueChappie;Server=localhost;uid=ProTrack2;pwd=protrack123;Connect Timeout=30;Min Pool Size=5;Max Pool Size=900;"); System.Data.SqlClient.SqlDataAdapter sqlDataAdapter = new System.Data.SqlClient.SqlDataAdapter(); sqlDataAdapter.SelectCommand = new System.Data.SqlClient.SqlCommand("SELECT TOP 0 * FROM " + typeObj.Name + "lib with (nolock)", sqlConnection); sqlDataAdapter.Fill(dataSet, typeObj.Name + "lib"); System.Data.DataTable tbl = dataSet.Tables[0]; System.Data.DataRow newRow = tbl.Rows.Add(); foreach (System.Data.DataColumn fld in tbl.Columns) { foreach (PropertyInfo imgFields in typeObj.GetProperties()) { if (imgFields.Name.Equals(fld.ColumnName)) { if (!fld.ReadOnly) { newRow.SetField(fld.ColumnName.ToString(), imgFields.GetValue(obj)); } } } } System.Data.DataRow dsRow = dataSet.Tables[typeObj.Name + "lib"].NewRow(); dsRow = newRow; new SqlCommandBuilder(sqlDataAdapter); int result = sqlDataAdapter.Update(dataSet, typeObj.Name + "lib"); } }
private void Initialise() { if (!initialised) { Uri host = new Uri(server); ConnectionConfiguration config = new ConnectionConfiguration(host); client = new ElasticLowLevelClient(config); initialised = true; } }
/** # 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 `ElasticLowLevelClient`, it will be a non-failover connection to `http://localhost:9200` */ public void InstantiateUsingAllDefaults() { var client = new ElasticLowLevelClient(); var tokenizers = new TokenizersDescriptor(); }