public static IElasticClient GetOrAddClient <TConfig>(
this IEphemeralCluster <TConfig> cluster,
Func <ConnectionSettings, ConnectionSettings> createSettings = null,
Func <ICollection <Uri>, IConnectionPool> createPool = null)
where TConfig : EphemeralClusterConfiguration
{
createSettings = createSettings ?? (s => s);
return(cluster.GetOrAddClient(c =>
{
var host = (RunningFiddler) ? "ipv4.fiddler" : "localhost";
createPool = createPool ?? (uris => new StaticConnectionPool(uris));
var connectionPool = createPool(c.NodesUris(host));
var connection = TestClient.Configuration.RunIntegrationTests ? TestClient.CreateLiveConnection() : new InMemoryConnection();
var settings = TestClient.CreateSettings(createSettings, connection, connectionPool);
var current = (IConnectionConfigurationValues)settings;
var notAlreadyAuthenticated = current.BasicAuthenticationCredentials == null && current.ClientCertificates == null;
var noCertValidation = current.ServerCertificateValidationCallback == null;
if (cluster.ClusterConfiguration.EnableSecurity && notAlreadyAuthenticated)
{
settings = settings.BasicAuthentication(ClusterAuthentication.Admin.Username, ClusterAuthentication.Admin.Password);
}
if (cluster.ClusterConfiguration.EnableSsl && noCertValidation)
{
var ca = new X509Certificate2(cluster.ClusterConfiguration.FileSystem.CaCertificate);
settings = settings.ServerCertificateValidationCallback(CertificateValidations.AllowAll);
}
var client = new ElasticClient(settings);
return client;
}));
}
public void SeenByVisitor()
{
var visitor = new DslPrettyPrintVisitor(TestClient.CreateSettings());
var query = this.QueryFluent(new QueryContainerDescriptor <Project>());
query.Accept(visitor);
var pretty = visitor.PrettyPrint;
pretty.Should().NotBeNullOrWhiteSpace();
}
[I] public void ThrowsExceptionOnConnectionError()
{
if (TestClient.RunningFiddler)
{
return; //fiddler meddles here
}
var client = new ElasticClient(TestClient.CreateSettings(port: 9500));
Action response = () => client.GetMany <Developer>(_ids.Select(i => i * 100));
response.ShouldThrow <ElasticsearchClientException>();
}
public void ExpressionsAreCachedButSeeDifferentTypes()
{
var connectionSettings = TestClient.CreateSettings(forceInMemory: true);
var client = new ElasticClient(connectionSettings);
var fieldNameOnA = client.Infer.Field(Field <A>(p => p.C.Name));
var fieldNameOnB = client.Infer.Field(Field <B>(p => p.C.Name));
/**
* Here we have to similary shaped expressions on coming from A and on from B
* that will resolve to the same field name, as expected
*/
fieldNameOnA.Should().Be("c.name");
fieldNameOnB.Should().Be("c.name");
/**
* now we create a new connection settings with a re-map for `C` on class `A` to `"d"`
* now when we resolve the field path for property `C` on `A`, it will be different than
* for property `C` on `B`
*/
var newConnectionSettings = TestClient.CreateSettings(forceInMemory: true, modifySettings: s => s
.InferMappingFor <A>(m => m
.Rename(p => p.C, "d")
)
);
var newClient = new ElasticClient(newConnectionSettings);
fieldNameOnA = newClient.Infer.Field(Field <A>(p => p.C.Name));
fieldNameOnB = newClient.Infer.Field(Field <B>(p => p.C.Name));
fieldNameOnA.Should().Be("d.name");
fieldNameOnB.Should().Be("c.name");
/** however we didn't break inferrence on the first client instance using its separate connection settings */
fieldNameOnA = client.Infer.Field(Field <A>(p => p.C.Name));
fieldNameOnB = client.Infer.Field(Field <B>(p => p.C.Name));
fieldNameOnA.Should().Be("c.name");
fieldNameOnB.Should().Be("c.name");
}
public void RequestPipeline()
{
var settings = TestClient.CreateSettings();
/** When calling Request(Async) on Transport the whole coordination of the request is deferred to a new instance in a `using` block. */
var pipeline = new RequestPipeline(settings, DateTimeProvider.Default, new MemoryStreamFactory(), new SearchRequestParameters());
pipeline.GetType().Should().Implement <IDisposable>();
/** However the transport does not instantiate RequestPipeline directly, it uses a pluggable `IRequestPipelineFactory`*/
var requestPipelineFactory = new RequestPipelineFactory();
var requestPipeline = requestPipelineFactory.Create(settings, DateTimeProvider.Default, new MemoryStreamFactory(), new SearchRequestParameters());
requestPipeline.Should().BeOfType <RequestPipeline>();
requestPipeline.GetType().Should().Implement <IDisposable>();
/** which can be passed to the transport when instantiating a client */
var transport = new Transport <ConnectionSettings>(settings, requestPipelineFactory, DateTimeProvider.Default, new MemoryStreamFactory());
/** this allows you to have requests executed on your own custom request pipeline */
}
public void RequestPipeline()
{
var settings = TestClient.CreateSettings();
/** When calling `Request()` or `RequestAsync()` on an `ITransport`,
* the whole coordination of the request is deferred to a new instance in a `using` block.
*/
var pipeline = new RequestPipeline(
settings,
DateTimeProvider.Default,
new MemoryStreamFactory(),
new SearchRequestParameters());
pipeline.GetType().Should().Implement <IDisposable>();
/** An `ITransport` does not instantiate a `RequestPipeline` directly; it uses a pluggable `IRequestPipelineFactory`
* to create it
*/
var requestPipelineFactory = new RequestPipelineFactory();
var requestPipeline = requestPipelineFactory.Create(
settings,
DateTimeProvider.Default, //<1> An <<date-time-providers,`IDateTimeProvider` implementation>>
new MemoryStreamFactory(),
new SearchRequestParameters());
requestPipeline.Should().BeOfType <RequestPipeline>();
requestPipeline.GetType().Should().Implement <IDisposable>();
/** You can pass your own `IRequestPipeline` implementation to the Transport when instantiating a client,
* allowing you to have requests executed on your own custom request pipeline
*/
var transport = new Transport <ConnectionSettings>(
settings,
requestPipelineFactory,
DateTimeProvider.Default,
new MemoryStreamFactory());
}
