public static int Main()
{
ElasticsearchVersion v = null;
// var clusterConfiguration = new EphemeralClusterConfiguration("6.0.0", numberOfNodes: 2);
// var ephemeralCluster = new EphemeralCluster(clusterConfiguration);
// var nodeConfiguration = new NodeConfiguration(clusterConfiguration, 9200);
// var elasticsearchNode = new ElasticsearchNode(nodeConfiguration);
////
// using (var node = new ElasticsearchNode("5.5.1"))
// {
// node.Subscribe(new ConsoleOutColorWriter());
// node.WaitForStarted(TimeSpan.FromMinutes(2));
// }
//
// using (var node = new ElasticsearchNode("6.0.0-beta2", @"c:\Data\elasticsearch-6.0.0-beta2"))
// {
// node.Subscribe();
// node.WaitForStarted(TimeSpan.FromMinutes(2));
// Console.ReadKey();
// }
// using (var cluster = new EphemeralCluster("6.0.0"))
// {
// cluster.Start();
// }
var config = new EphemeralClusterConfiguration("6.2.3", XPack | Security | SSL, null, 1)
{
PrintYamlFilesInConfigFolder = true,
ShowElasticsearchOutputAfterStarted = true
};
using (var cluster = new EphemeralCluster(config))
{
cluster.Start();
var nodes = cluster.NodesUris();
var connectionPool = new StaticConnectionPool(nodes);
var settings = new ConnectionSettings(connectionPool).EnableDebugMode();
if (config.EnableSecurity && !config.EnableSsl)
{
settings = settings.BasicAuthentication(ClusterAuthentication.Admin.Username, ClusterAuthentication.Admin.Password);
}
if (config.EnableSsl)
{
settings = settings.ServerCertificateValidationCallback(CertificateValidations.AllowAll);
settings = settings.ClientCertificate(new X509Certificate2(config.FileSystem.ClientCertificate));
}
var client = new ElasticClient(settings);
Console.Write(client.XPackInfo().DebugInformation);
}
//
// Console.WriteLine($".. DONE ...");
return(0);
}
public override ConnectionSettings Authenticate(ConnectionSettings s) => s // <1> Set the client certificate on `ConnectionSettings`
.ClientCertificate(
ClientCertificate.LoadWithPrivateKey(
this.Node.FileSystem.ClientCertificate, // <2> The path to the `.cer` file
this.Node.FileSystem.ClientPrivateKey, // <3> The path to the `.key` file
"") // <4> The password for the private key
);
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var settings = new ConnectionSettings(new Uri(_options.Uri));
if (_options.AuthenticateWithBasicCredentials)
{
settings = settings.BasicAuthentication(_options.UserName, _options.Password);
}
else if (_options.AuthenticateWithCertificate)
{
settings = settings.ClientCertificate(_options.Certificate);
}
var lowlevelClient = new ElasticClient(settings);
var pingResult = await lowlevelClient.PingAsync(cancellationToken : cancellationToken);
var isSuccess = pingResult.ApiCall.HttpStatusCode == 200;
return(isSuccess
? HealthCheckResult.Healthy()
: new HealthCheckResult(context.Registration.FailureStatus));
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
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 async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
if (!_connections.TryGetValue(_options.Uri, out ElasticClient lowLevelClient))
{
var settings = new ConnectionSettings(new Uri(_options.Uri));
if (_options.RequestTimeout.HasValue)
{
settings = settings.RequestTimeout(_options.RequestTimeout.Value);
}
if (_options.AuthenticateWithBasicCredentials)
{
settings = settings.BasicAuthentication(_options.UserName, _options.Password);
}
else if (_options.AuthenticateWithCertificate)
{
settings = settings.ClientCertificate(_options.Certificate);
}
if (_options.CertificateValidationCallback != null)
{
settings = settings.ServerCertificateValidationCallback(_options.CertificateValidationCallback);
}
lowLevelClient = new ElasticClient(settings);
if (!_connections.TryAdd(_options.Uri, lowLevelClient))
{
lowLevelClient = _connections[_options.Uri];
}
}
var pingResult = await lowLevelClient.PingAsync(ct : cancellationToken);
var isSuccess = pingResult.ApiCall.HttpStatusCode == 200;
return(isSuccess
? HealthCheckResult.Healthy()
: new HealthCheckResult(context.Registration.FailureStatus));
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
private IElasticClient GetElasticClient(ESOptions esOptions)
{
Uri node = new Uri(esOptions.Host);
ConnectionSettings settings = new ConnectionSettings(node);
settings.DefaultIndex(esOptions.Index);
settings.DefaultTypeName(esOptions.TypeName);
#region Auth
if (!String.IsNullOrEmpty(esOptions.UserName))
{
settings.BasicAuthentication(esOptions.UserName, esOptions.Password);
}
if (!String.IsNullOrEmpty(esOptions.Cert))
{
settings.ClientCertificate(esOptions.Cert);
}
#endregion
return(new ElasticClient(settings));
}
protected override ConnectionSettings Authenticate(ConnectionSettings s) => s // <1> Set the client certificate on `ConnectionSettings` .ClientCertificate(new X509Certificate2(this.ClusterConfiguration.FileSystem.ClientCertificate));
public override ConnectionSettings Authenticate(ConnectionSettings s) => s
//.ClientCertificate(this.Node.FileSystem.ClientCertificate);
.ClientCertificate(
ClientCertificate.LoadWithPrivateKey(this.Node.FileSystem.ClientCertificate, this.Node.FileSystem.ClientPrivateKey, "")
);
private static ElasticClient GetClient(IList <string> endpoints,
string defaultIndex,
ConnectionConfig config,
ConnectionPool connectionPool)
{
if (!endpoints.HasItems())
{
throw new ArgumentException(string.Format(Utils.ARGUMENT_EMPTY_LIST_MESSAGE, nameof(endpoints)),
nameof(endpoints));
}
var uris = endpoints.Select(x => new Uri(x));
IConnectionPool pool;
switch (connectionPool)
{
case ConnectionPool.SingleNode:
pool = new SingleNodeConnectionPool(new Uri(endpoints.First()));
break;
case ConnectionPool.Static:
pool = new StaticConnectionPool(uris);
break;
case ConnectionPool.Sniffing:
pool = new SniffingConnectionPool(uris);
break;
case ConnectionPool.Sticky:
pool = new StickyConnectionPool(uris);
break;
default:
throw new ArgumentOutOfRangeException(nameof(connectionPool), connectionPool, null);
}
var connectionSettings = new ConnectionSettings(pool)
.ConnectionLimit(config?.ConnectionLimit > 0 ? config.ConnectionLimit : 80)
.DisableAutomaticProxyDetection(config?.DisableAutomaticProxyDetection ?? false)
.DisableDirectStreaming(config?.EnableDebugMode ?? false)
.DisablePing(config?.DisablePings ?? false)
.DefaultIndex(defaultIndex)
.EnableHttpCompression(config?.EnableHttpCompression ?? true)
.EnableHttpPipelining(config?.EnableHttpPipelining ?? true)
.EnableTcpKeepAlive(config?.KeepAliveTime.Ticks > 0
? config.KeepAliveTime
: TimeSpan.FromMilliseconds(2000),
config?.KeepAliveInterval.Ticks > 0
? config.KeepAliveInterval
: TimeSpan.FromMilliseconds(2000))
.MaximumRetries(config?.MaxRetries > 0 ? config.MaxRetries : 10)
.MaxRetryTimeout(
config?.MaxRetryTimeout.Ticks > 0 ? config.MaxRetryTimeout : TimeSpan.FromSeconds(60))
.PrettyJson(config?.EnableDebugMode ?? false)
.RequestTimeout(config?.RequestTimeout.Ticks > 0
? config.RequestTimeout
: TimeSpan.FromSeconds(60))
.SniffLifeSpan(config?.SniffLifeSpan.Ticks > 0
? config.SniffLifeSpan
: TimeSpan.FromHours(1))
.SniffOnConnectionFault(config?.SniffsOnConnectionFault ?? true)
.SniffOnStartup(config?.SniffsOnStartup ?? true)
.ThrowExceptions(config?.ThrowExceptions ?? false);
if (!string.IsNullOrWhiteSpace(config?.BasicAuthenticationUsername) &&
!string.IsNullOrWhiteSpace(config.BasicAuthenticationPassword))
{
connectionSettings.BasicAuthentication(config.BasicAuthenticationUsername, config.BasicAuthenticationPassword);
}
if (config?.ClientCerfificates != null && config.ClientCerfificates.HasItems())
{
connectionSettings.ClientCertificates(config.ClientCerfificates);
}
else if (config?.ClientCerfificate != null)
{
connectionSettings.ClientCertificate(config.ClientCerfificate);
}
if (config?.DeadTimeout.Ticks > 0)
{
connectionSettings.DeadTimeout(config.DeadTimeout);
}
if (config?.Headers != null && config.Headers.HasItems())
{
connectionSettings.GlobalHeaders(config.Headers);
}
if (config?.QueryStringParameters != null && config.QueryStringParameters.HasItems())
{
connectionSettings.GlobalQueryStringParameters(config.QueryStringParameters);
}
if (config?.MaxDeadTimeout.Ticks > 0)
{
connectionSettings.MaxDeadTimeout(config.DeadTimeout);
}
if (config?.NodePredicate != null)
{
connectionSettings.NodePredicate(config.NodePredicate);
}
if (config?.RequestCompletedHandler != null)
{
connectionSettings.OnRequestCompleted(config.RequestCompletedHandler);
}
if (config?.RequestDataCreatedHandler != null)
{
connectionSettings.OnRequestDataCreated(config.RequestDataCreatedHandler);
}
if (config?.PingTimeout.Ticks > 0)
{
connectionSettings.PingTimeout(config.PingTimeout);
}
if (!string.IsNullOrWhiteSpace(config?.ProxyAddress))
{
connectionSettings.Proxy(new Uri(config.ProxyAddress), config?.ProxyUsername, config?.ProxyPassword);
}
if (config?.ServerCertificateValidationCallback != null)
{
connectionSettings.ServerCertificateValidationCallback(config.ServerCertificateValidationCallback);
}
return(new ElasticClient(connectionSettings));
}
