public static void AddElasticsearch(this IServiceCollection services, IConfiguration configuration) { var settings = new ConnectionSettings(new Uri(configuration["ElasticsearchSettings:uri"])); var defaultIndex = configuration["ElasticsearchSettings:defaultIndex"]; if (!string.IsNullOrEmpty(defaultIndex)) { settings = settings.DefaultIndex(defaultIndex); } // The authentication options below are set if you have non-null/empty // settings in the configuration. var apiKeyId = configuration["ElasticsearchSettings:apiKeyId"]; var apiKey = configuration["ElasticsearchSettings:apiKey"]; if (!string.IsNullOrEmpty(apiKeyId) && !string.IsNullOrEmpty(apiKey)) { settings = settings.ApiKeyAuthentication(apiKeyId, apiKey); } else { var basicAuthUser = configuration["ElasticsearchSettings:basicAuthUser"]; var basicAuthPassword = configuration["ElasticsearchSettings:basicAuthPassword"]; if (!string.IsNullOrEmpty(basicAuthUser) && !string.IsNullOrEmpty(basicAuthPassword)) { settings = settings.BasicAuthentication(basicAuthUser, basicAuthPassword); } } var client = new ElasticClient(settings); services.AddSingleton <IElasticClient>(client); // It's Thread safe }
private async Task <bool> SwitchToNextNodeAsync(CancellationToken cancellationToken = default) { if (_currentNode == null) { _currentNode = _nodes[0]; } else { var currentIndex = _nodes.IndexOf(_currentNode); _currentNode = currentIndex == _nodes.Count - 1 ? _nodes[0] : _nodes[currentIndex + 1]; } var uri = new Uri(_currentNode.Host); var settings = new ConnectionSettings(uri); settings.EnableHttpCompression(); settings.MaximumRetries(_maximumRetries); settings.MaxRetryTimeout(_maxRetryTimeout); switch (_currentNode.AuthenticationType) { case AuthenticationType.Basic: settings.BasicAuthentication(_currentNode.UserName, _currentNode.Password); break; case AuthenticationType.ApiKey: settings.ApiKeyAuthentication(_currentNode.Id, _currentNode.ApiKey); break; default: break; } _client = new ElasticClient(settings); _logger?.LogInformation($"Trying to connect to {uri} ({_eventLogItemsIndex})"); var response = await _client.PingAsync(pd => pd, cancellationToken); if (!(response.OriginalException is TaskCanceledException)) { if (!response.IsValid) { _logger?.LogWarning($"Failed to connect to {uri} ({_eventLogItemsIndex}): {response.OriginalException.Message}"); } else { _logger?.LogInformation($"Successfully connected to {uri} ({_eventLogItemsIndex})"); } } return(response.IsValid); }
public static ElasticClient CreateClient(ElasticSearchConnectionString connectionString, TimeSpan?requestTimeout = null, TimeSpan?pingTimeout = null) { Uri[] nodesUrls = connectionString.Nodes.Select(x => new Uri(x)).ToArray(); StaticConnectionPool pool = new StaticConnectionPool(nodesUrls); ConnectionSettings settings = new ConnectionSettings(pool); if (requestTimeout != null) { settings.RequestTimeout(requestTimeout.Value); } if (pingTimeout != null) { settings.PingTimeout(pingTimeout.Value); } if (connectionString.Authentication != null) { if (connectionString.Authentication.Basic != null) { settings.BasicAuthentication(connectionString.Authentication.Basic.Username, connectionString.Authentication.Basic.Password); } else if (connectionString.Authentication.ApiKey != null) { settings.ApiKeyAuthentication(connectionString.Authentication.ApiKey.ApiKeyId, connectionString.Authentication.ApiKey.ApiKey); } else if (connectionString.Authentication.Certificate != null) { if (connectionString.Authentication.Certificate.CertificatesBase64.Length == 1) { var cert = new X509Certificate2(Convert.FromBase64String(connectionString.Authentication.Certificate.CertificatesBase64.First())); settings.ClientCertificate(cert); } else { var certificates = new X509CertificateCollection(); foreach (var certificateBase64 in connectionString.Authentication.Certificate.CertificatesBase64) { certificates.Add(new X509Certificate2(Convert.FromBase64String(certificateBase64))); } settings.ClientCertificates(certificates); } } } ElasticClient client = new(settings); return(client); }
public ElasticsearchContext(IOptions <ElsaElasticsearchOptions> options) { var pool = new SniffingConnectionPool(options.Value.Uri); var settings = new ConnectionSettings(pool); if (options.Value.BasicAuthentication != null) { settings.BasicAuthentication(options.Value.BasicAuthentication.Username, options.Value.BasicAuthentication.Password); } else if (options.Value.ApiKeyAuthentication != null) { settings.ApiKeyAuthentication(options.Value.ApiKeyAuthentication.Id, options.Value.ApiKeyAuthentication.ApiKey); } Client = new ElasticClient(settings); }
public ElasticSearchClientWrapper(IConfig config, IErrorLog errorLog, ITenantService tenantService) { _errorLog = errorLog; _tenantService = tenantService; var node = new Uri(config.SearchUrl); var settings = new ConnectionSettings(node) .DefaultIndex(IndexName).DisableDirectStreaming(); if (!string.IsNullOrEmpty(config.SearchKey)) { var pair = config.SearchKey.Split("|"); if (pair.Length == 2) { settings.ApiKeyAuthentication(pair[0], pair[1]); } } _client = new ElasticClient(settings); }
public ElasticsearchReporter(string[] elasticsearchUris, string indexName , string apiId = null, string apiKey = null , string username = null, string password = null , int?timeoutSeconds = null, bool debug = false) { _uris = elasticsearchUris; _indexName = indexName; _debug = debug; //https://www.elastic.co/guide/en/elasticsearch/client/net-api/2.x/connection-pooling.html if (null == elasticsearchUris || 0 == elasticsearchUris.Length) { throw new ArgumentException("Uri list should not be empty", nameof(elasticsearchUris)); } IConnectionPool pool = elasticsearchUris.Length == 1 ? new SingleNodeConnectionPool(new Uri(elasticsearchUris.First())) as IConnectionPool : new StaticConnectionPool(_uris.Select(u => new Uri(u))); var _settings = new ConnectionSettings(pool) .DefaultIndex(indexName) //.DefaultMappingFor<ElasticsearchErrorDocument>(m => m) //.IndexName()) ; if (!string.IsNullOrEmpty(apiId)) { _settings.ApiKeyAuthentication(apiId, apiKey); } if (!string.IsNullOrEmpty(username)) { _settings.BasicAuthentication(username, password); _settings.ServerCertificateValidationCallback((o, certificate, chain, errors) => true); } if (timeoutSeconds.HasValue) { _settings = _settings.RequestTimeout(TimeSpan.FromSeconds(timeoutSeconds.Value)) .MaxDeadTimeout(TimeSpan.FromSeconds(timeoutSeconds.Value)); } if (_debug) { _settings = _settings.DisableDirectStreaming(); } _client = new ElasticsearchImpl.ElasticClient(new ElasticClient(_settings)); }
public static void AddElasticsearch(this IServiceCollection services, IConfiguration configuration) { var settings = new ConnectionSettings(new Uri(configuration["ElasticsearchSettings:uri"])); var defaultIndex = configuration["ElasticsearchSettings:defaultIndex"]; if (!string.IsNullOrEmpty(defaultIndex)) { settings = settings.DefaultIndex(defaultIndex); } // The authentication options below are set if you have non-null/empty // settings in the configuration. These are just samples -- there are // other authentication methods available. var apiKeyId = configuration["ElasticsearchSettings:apiKeyId"]; var apiKey = configuration["ElasticsearchSettings:apiKey"]; if (!string.IsNullOrEmpty(apiKeyId) && !string.IsNullOrEmpty(apiKey)) { settings = settings.ApiKeyAuthentication(apiKeyId, apiKey); } else { var basicAuthUser = configuration["ElasticsearchSettings:basicAuthUser"]; var basicAuthPassword = configuration["ElasticsearchSettings:basicAuthPassword"]; if (!string.IsNullOrEmpty(basicAuthUser) && !string.IsNullOrEmpty(basicAuthPassword)) { settings = settings.BasicAuthentication(basicAuthUser, basicAuthPassword); } } var client = new ElasticClient(settings); // ElasticClient is thread-safe // See https://www.elastic.co/guide/en/elasticsearch/client/net-api/current/lifetimes.html services.AddSingleton <IElasticClient>(client); }
public static async System.Threading.Tasks.Task Log(IfyContext context, Event log) { if (EventLogConfig == null || EventLogConfig.Settings == null || EventLogConfig.Settings.Count == 0 || EventLogConfig.Settings["baseurl"] == null || EventLogConfig.Settings["index"] == null || EventLogConfig.Settings["pipeline"] == null || string.IsNullOrEmpty(EventLogConfig.Settings["baseurl"].Value)) { throw new Exception("Missing event log configuration in web.config"); } var json = JsonConvert.SerializeObject(log); context.LogDebug(context, "Event log : " + json); var settings = new ConnectionSettings(new SingleNodeConnectionPool(new Uri(EventLogConfig.Settings["baseurl"].Value)), sourceSerializer: JsonNetSerializer.Default); if (EventLogConfig.Settings["auth_apikey"] != null && !string.IsNullOrEmpty(EventLogConfig.Settings["auth_apikey"].Value)) { settings.ApiKeyAuthentication(new Elasticsearch.Net.ApiKeyAuthenticationCredentials(EventLogConfig.Settings["auth_apikey"].Value)); } else if (EventLogConfig.Settings["auth_username"] != null && !string.IsNullOrEmpty(EventLogConfig.Settings["auth_username"].Value) && EventLogConfig.Settings["auth_password"] != null) { settings.BasicAuthentication(EventLogConfig.Settings["auth_username"].Value, EventLogConfig.Settings["auth_password"].Value); } var client = new ElasticClient(settings); try{ var response = await client.IndexAsync(log, e => e.Index(EventLogConfig.Settings["index"].Value).Pipeline(EventLogConfig.Settings["pipeline"].Value)); context.LogDebug(context, string.Format("Log event response: (ID={0}) {1}", response.Id, response.DebugInformation)); }catch (Exception e) { context.LogError(context, "Log event error (POST): " + e.Message); context.WriteError("Log event error (POST): " + e.Message); } }