[Fact] public void StaticPoolWithstandsConcurrentReadAndWrites()
        {
            var uris       = Enumerable.Range(9200, _numberOfNodes).Select(p => new Uri("http://localhost:" + p));
            var staticPool = new StaticConnectionPool(uris, false);

            Action callStatic = () => AssertCreateView(staticPool);

            callStatic.Should().NotThrow();
        }
Example #2
0
 public ExampleTest(TestCluster cluster)
 {
     this.Client = cluster.GetOrAddClient(c => {
         var nodes          = cluster.NodesUris();
         var connectionPool = new StaticConnectionPool(nodes);
         var settings       = new ConnectionSettings(connectionPool).EnableDebugMode();
         return(new ElasticClient(settings));
     });
 }
Example #3
0
        public ElasticAccess(string connString)
        {
            var pool     = new StaticConnectionPool(connString.Split(',').Select(uri => new Uri(uri)));
            var settings = new ConnectionSettings(pool);

            settings.DisableDirectStreaming();

            client = new ElasticClient(settings);
        }
Example #4
0
        [U] public void EachViewStartsAtNexPositionAndWrapsOver()
        {
            var uris         = Enumerable.Range(9200, NumberOfNodes).Select(p => new Uri("http://localhost:" + p));
            var staticPool   = new StaticConnectionPool(uris, randomize: false);
            var sniffingPool = new SniffingConnectionPool(uris, randomize: false);

            this.AssertCreateView(staticPool);
            this.AssertCreateView(sniffingPool);
        }
Example #5
0
        private ElasticClient SetupElasticSearch()
        {
            var nodes = new Uri[]
            {
                new Uri("http://localhost:9200")
                // new Uri("http://ipv4.fiddler:9200")  //use fiddler to see messages to & from elasticsearch
            };
            var pool     = new StaticConnectionPool(nodes);
            var settings = new ConnectionSettings(
                pool,
                new HttpConnection(),
                new SerializerFactory((jsonSettings, nestSettings) =>
                                      jsonSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore)
                );


            /****
            * USE THE FOLLOWING CODE to DEBUG or LOG without Fiddler
            *           var list = new List<string>();
            *
            *           settings
            *           .DisableDirectStreaming()
            *               .DisableAutomaticProxyDetection(true)
            *                   .OnRequestCompleted(response =>
            *                   {
            *                       // log out the request and the request body, if one exists for the type of request
            *                       if (response.RequestBodyInBytes != null)
            *                       {
            *                           list.Add(
            *                               $"{response.HttpMethod} {response.Uri} \n" +
            *                               $"{Encoding.UTF8.GetString(response.RequestBodyInBytes)}"); //this is where the request JSON will go
            *                       }
            *                       else
            *                       {
            *                           list.Add($"{response.HttpMethod} {response.Uri}");
            *                       }
            *
            *                       // log out the response and the response body, if one exists for the type of response
            *                       if (response.ResponseBodyInBytes != null)
            *                       {
            *                           list.Add($"Status: {response.HttpStatusCode}\n" +
            *                                    $"{Encoding.UTF8.GetString(response.ResponseBodyInBytes)}\n" +
            *                                    $"{new string('-', 30)}\n");
            *                       }
            *                       else
            *                       {
            *                           list.Add($"Status: {response.HttpStatusCode}\n" +
            *                                    $"{new string('-', 30)}\n");
            *                       }
            *                   });
            ****/

            var client = new ElasticClient(settings);

            return(client);
        }
Example #6
0
        private static void ManualConfigRun()
        {
            ElasticVersion version = "latest";

            var plugins =
                new ElasticsearchPlugins(ElasticsearchPlugin.IngestGeoIp, ElasticsearchPlugin.IngestAttachment);
            var features = Security | XPack | SSL;
            var config   = new EphemeralClusterConfiguration(version, features, plugins, numberOfNodes: 1)
            {
                HttpFiddlerAware = true,
                ShowElasticsearchOutputAfterStarted = true,
                CacheEsHomeInstallation             = false,
                TrialMode = XPackTrialMode.Trial,
                NoCleanupAfterNodeStopped = false,
            };

            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)
                {
                    settings = settings.BasicAuthentication(ClusterAuthentication.Admin.Username,
                                                            ClusterAuthentication.Admin.Password);
                }
                if (config.EnableSsl)
                {
                    settings = settings.ServerCertificateValidationCallback(CertificateValidations.AllowAll);
                }

                var client = new ElasticClient(settings);

                var clusterConfiguration = new Dictionary <string, object>()
                {
                    { "cluster.routing.use_adaptive_replica_selection", true },
                    { "cluster.remote.remote-cluster.seeds", "127.0.0.1:9300" }
                };


                var putSettingsResponse = client.ClusterPutSettings(new ClusterPutSettingsRequest
                {
                    Transient = clusterConfiguration
                });


                Console.Write(client.XPackInfo().DebugInformation);
                Console.WriteLine("Press any key to exit");
                Console.ReadKey();
                Console.WriteLine("Exitting..");
            }

            Console.WriteLine("Done!");
        }
Example #7
0
        private static ElasticClient CreateClient(EphemeralCluster cluster)
        {
            var nodes          = cluster.NodesUris();
            var connectionPool = new StaticConnectionPool(nodes);
            var settings       = new ConnectionSettings(connectionPool)
                                 //.Proxy(new Uri("http://localhost:8080"), "", "")
                                 .EnableDebugMode();

            return(new ElasticClient(settings));
        }
        private static IElasticClient GetElasticClient(ElasticSearchConfiguration elasticConfiguration)
        {
            var pool     = new StaticConnectionPool(elasticConfiguration.EsNodeUris);
            var settings = new ConnectionSettings(pool).DefaultIndex(elasticConfiguration.EsIndex)
                           .DefaultMappingFor <DummyDoc>(m => m.IndexName(elasticConfiguration.EsIndex).TypeName(typeof(DummyDoc).Name))
                           .EnablePrometheus(); //  Enable Prometheus instrumentation


            return(new ElasticClient(settings));
        }
Example #9
0
        /// <summary>
        /// 创建连接设置实例
        /// </summary>
        /// <returns></returns>
        public static ConnectionSettings CreateInstance()
        {
            var connectPool = new StaticConnectionPool(Nodes);

            return(new ConnectionSettings(connectPool)
                   .DefaultIndex(Constant.DefaultIndex)
                   .RequestTimeout(TimeSpan.FromMinutes(2))
                   .EnableHttpCompression()
                   .PrettyJson());
        }
        protected override void InitializeTarget()
        {
            base.InitializeTarget();

            var uri = GetConnectionString(ConnectionStringName) ?? Uri;
            var nodes = uri.Split(',').Select(url => new Uri(url));
            var connectionPool = new StaticConnectionPool(nodes);
            var config = new ConnectionConfiguration(connectionPool);
            _client = new ElasticsearchClient(config, serializer:ElasticsearchSerializer);
        }
Example #11
0
        public ESSever(IConfiguration configuration, IMemoryCache memoryCache_arg)
        {
            memoryCache = memoryCache_arg;
            var uris           = configuration["ElasticSearchContext:Url"].Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(x => new Uri(x));
            var connectionPool = new StaticConnectionPool(uris);
            var settings       = new ConnectionSettings(connectionPool).RequestTimeout(TimeSpan.FromSeconds(30));//.BasicAuthentication("elastic", "n@@W#RJQ$z1#")

            this.ElasticJsonClient = new ElasticLowLevelClient(settings);
            this.ElasticLinqClient = new ElasticClient(settings);
        }
        public static ElasticClient ElasticClient(string defaultIndex)
        {
            var connectionPool     = new StaticConnectionPool(GetUris());
            var connectionSettings = new ConnectionSettings(connectionPool).DisableDirectStreaming();

            connectionSettings.BasicAuthentication("elastic", "password"); // into a config.....
            var elasticClient = new ElasticClient(connectionSettings.DefaultIndex(defaultIndex));

            return(elasticClient);
        }
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="url"></param>
        public EsClient(string nodeid, string url)
        {
            nodeId = nodeid;

            var uris           = url.Split(",").ToList().ConvertAll(x => new Uri(x));
            var connectionPool = new StaticConnectionPool(uris);
            var settings       = new ConnectionConfiguration(connectionPool).RequestTimeout(TimeSpan.FromSeconds(30));

            this.client = new ElasticLowLevelClient(settings);
        }
 public static IElasticClient GetOrAddClient(this IEphemeralCluster cluster)
 {
     return(Clients.GetOrAdd(cluster, (c) =>
     {
         var connectionPool = new StaticConnectionPool(c.NodesUris());
         var settings = new ConnectionSettings(connectionPool);
         var client = new ElasticClient(settings);
         return client;
     }));
 }
        public void AllNodesWillBeMarkedDead()
        {
            using (var fake = new AutoFake(callsDoNothing: true))
            {
                //set up a fake datetimeprovider
                var dateTimeProvider = fake.Resolve <IDateTimeProvider>();
                fake.Provide(dateTimeProvider);
                //create a connectionpool that uses the fake datetimeprovider
                var connectionPool = new StaticConnectionPool(
                    _uris,
                    dateTimeProvider: dateTimeProvider
                    );
                var config = new ConnectionConfiguration(connectionPool);
                fake.Provide <IConnectionConfigurationValues>(config);

                //Now() on the fake still means Now()
                A.CallTo(() => dateTimeProvider.Now()).Returns(DateTime.UtcNow);
                //Set up individual mocks for each DeadTime(Uri uri,...) call
                //where uri matches one of the node ports
                var calls = _uris.Select(u =>
                                         A.CallTo(() => dateTimeProvider.DeadTime(
                                                      A <Uri> .That.Matches(uu => uu.Port == u.Port),
                                                      A <int> ._, A <int?> ._, A <int?> ._
                                                      ))).ToList();

                //all the fake mark dead calls return 60 seconds into the future
                foreach (var call in calls)
                {
                    call.Returns(DateTime.UtcNow.AddSeconds(60));
                }

                //When we do a GET on / we always recieve a 503
                var getCall = A.CallTo(() => fake.Resolve <IConnection>().GetSync(A <Uri> ._, A <IRequestConfiguration> ._));
                getCall.Returns(_bad);

                var transport = this.ProvideTransport(fake);
                var pingCall  = FakeCalls.PingAtConnectionLevel(fake);
                pingCall.Returns(_ok);
                var client = fake.Resolve <ElasticsearchClient>();

                //Since we always get a 503 we should see an out of nodes exception
                Assert.Throws <MaxRetryException>(() => client.Info());

                pingCall.MustHaveHappened(Repeated.Exactly.Times(4));

                //The call should be tried on all the nodes
                getCall.MustHaveHappened(Repeated.Exactly.Times(4));

                //We should see each individual node being marked as dead
                foreach (var call in calls)
                {
                    call.MustHaveHappened(Repeated.Exactly.Once);
                }
            }
        }
Example #16
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext <ApplicationDbContext>(options =>
                                                         options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

            services.AddIdentity <ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores <ApplicationDbContext>()
            .AddDefaultTokenProviders();

            // Add application services.
            services.AddTransient <IEmailSender, EmailSender>();

            services.AddMvc();
            AutoMapper.Mapper.Initialize(c => c.AddProfile <ILanni.FarmMarket.Repository.Mongo.AutoMapperProfile>());
            Elasticsearch.Net.StaticConnectionPool pool = new StaticConnectionPool(new[] { new Uri("http://localhost:9200") });
            ConnectionSettings estSettings = new ConnectionSettings(pool);

            estSettings.BasicAuthentication("elastic", "123456");
            estSettings.InferMappingFor <Models.Product>(d => d.IdProperty(p => p.Id).IndexName("product").TypeName("product"));
            ElasticClient client = new ElasticClient(estSettings);

            services.AddSingleton <ElasticClient>(client);

            MongoClientSettings mSettings = new MongoClientSettings()
            {
                Credential = MongoCredential.CreateCredential("admin", "sa", "1"),
                Server     = new MongoServerAddress("127.0.0.1", 27017),
            };
            MongoClient mClient = new MongoClient(mSettings);

            services.AddSingleton <MongoClient>(mClient);

            services.AddSingleton <ILanni.FarmMarket.MQ.Settings>(new ILanni.FarmMarket.MQ.Settings());

            var rmqConnFactory = new RabbitMQ.Client.ConnectionFactory()
            {
                UserName = "******",
                Password = "******"
            };

            services.AddSingleton <RabbitMQ.Client.ConnectionFactory>(rmqConnFactory);

            PoolingSettings mqSetting = new PoolingSettings()
            {
                MaxChannelPerConnection = 5, MaxConnections = 2
            };
            ChannelPool channelPool = new ChannelPool(rmqConnFactory, mqSetting);

            services.AddSingleton(channelPool);

            services.AddScoped <ProductRepository>();
            services.AddScoped <ProductPublisher>();
            services.AddScoped <ProductService>();
        }
Example #17
0
        static void Test()
        {
            var nodes = new Uri[]
            {
                new Uri("http://10.204.124.222:9200"),
            };

            var pool = new StaticConnectionPool(nodes);

            var settings       = new ConnectionSettings(pool).DefaultIndex("photo_album_image");
            var client         = new ElasticClient(settings);
            var lowLevelClient = new ElasticLowLevelClient(settings);
            var data           = new ImageModel
            {
                Description = " 说明 ",
                CreateTime  = DateTime.Now,
                Filename    = "filename.jpng",
                KeyWorld    = new System.Collections.Generic.List <string> {
                    "test"
                },
                Id       = Guid.NewGuid().ToString(),
                Location = "shengzheng",
                Subject  = "有望",
                Videos   = "test.mp4"
            };

            var ndexResponse = lowLevelClient.Index <ImageModel>("索引", "PostData", PostData.Serializable(data));

            var searchResponse = lowLevelClient.Search <StringResponse>("people", PostData.Serializable(new
            {
                from  = 0,
                size  = 10,
                query = new
                {
                    match = new
                    {
                        firstName = new
                        {
                            query = "Martijn"
                        }
                    }
                }
            }));

            var successful   = searchResponse.Success;
            var responseJson = searchResponse.Body;

            var response = client.IndexDocument(data);

            var t             = response.Result;
            var searchReponse = client.Search <ImageModel>(s => s.From(0).Size(10).Query(q => q.
                                                                                         Match(m => m.Field(f => f.Filename).Query("filename.jpng"))));
            var people = searchReponse.Documents;
        }
Example #18
0
        protected StaticConnectionPool GetElasticPool()
        {
            // Get the elastic nodes
            var nodeUris = _indexNodes.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
            var nodes    = nodeUris.Select(u => new Uri(u)).ToList();

            // Create the elastic pool
            var pool = new StaticConnectionPool(nodes);

            return(pool);
        }
        public static void LoadData()
        {
            var nodes = new List <Uri> {
                new Uri("http://*****:*****@"C:\cities_canada-usa.csv"))
            {
                if (!reader.EndOfStream)
                {
                    reader.ReadLine();
                }

                var documents = new List <City>();
                while (!reader.EndOfStream)
                {
                    var line   = reader.ReadLine();
                    var values = line.Split(';');

                    //0 - id

                    //1 - name

                    //3 - alt_name

                    //4 - lat

                    //5 - lon

                    //8 - country_code
                    documents.Add(new City
                    {
                        Id       = int.Parse(values[0]),
                        Name     = values[1],
                        AltName  = values[3],
                        Country  = values[8],
                        Location = new Location(double.Parse(values[4]), double.Parse(values[5])),
                        FullText = string.Concat(values[1], ", ", values[8])
                    });
                }

                var result = client.IndexMany(documents, "city");
            }
        }
Example #20
0
 /// <summary>
 /// 创建ElasticClient实例
 /// </summary>
 private ElasticClient CreateEcInstance()
 {
     if (null == _elasticClient)
     {
         var lstUrls  = _config.Server.Split(',').Select(o => new Uri(o)).ToList();
         var pool     = new StaticConnectionPool(lstUrls);
         var settings = new ConnectionSettings(pool);
         _elasticClient = new ElasticClient(settings);
     }
     return(_elasticClient);
 }
Example #21
0
        public void InitElasticSearchUsingPool()
        {
            //var uri = new Uri("http://*****:*****@"http://localhost:{port}"));
            var pool     = new StaticConnectionPool(uris);
            var settings = new ConnectionSettings(pool);

            _elasticClient = new ElasticClient(settings);
        }
Example #22
0
        public void UsesRelativePathForPing()
        {
            var pool       = new StaticConnectionPool(new[] { new Uri("http://localhost:9200/elasticsearch/") });
            var connection = new HttpWebRequestConnectionTests.TestableHttpWebRequestConnection();
            var settings   = new ConnectionSettings(pool, connection);

            var client         = new ElasticClient(settings);
            var healthResponse = client.Ping();

            connection.LastRequest.Address.AbsolutePath.Should().StartWith("/elasticsearch/");
        }
Example #23
0
 /// <summary>
 /// 通过连接池链接
 /// </summary>
 public void ConnectionPoolLink()
 {
     var nodes = new Uri[] {
         new Uri("http://myserver1:9200"),
         new Uri("http://myserver2:9200"),
         new Uri("http://myserver3:9200")
     };
     var pool     = new StaticConnectionPool(nodes);
     var settings = new ConnectionSettings(pool);
     var client   = new ElasticClient(settings);
 }
        public ESearchService()
        {
            var nodes = new Uri[] {
                new Uri(mainPath)
            };

            var pool     = new StaticConnectionPool(nodes);
            var settings = new ConnectionSettings(pool).DisableDirectStreaming();

            _client = new ElasticClient(settings);
        }
Example #25
0
        public GithubIssue2052()
        {
            var pool = new StaticConnectionPool(new List <Uri> {
                new Uri("http://localhost:9200")
            });
            var memoryConnection   = new InMemoryConnection();
            var connectionSettings = new ConnectionConfiguration(pool, memoryConnection)
                                     .DisableDirectStreaming();

            this._client = new ElasticLowLevelClient(connectionSettings);
        }
Example #26
0
 /**
  * ==== Custom indexing client
  *
  * Since Elasticsearch will automatically reroute ingest requests to ingest nodes, you don't have to specify or configure any routing
  * information. However, if you're doing heavy ingestion and have dedicated ingest nodes, it makes sense to send index requests to
  * these nodes directly, to avoid any extra hops in the cluster.
  *
  * The simplest way to achieve this is to create a dedicated "indexing" client instance, and use it for indexing requests.
  */
 public void CustomClient()
 {
     var pool = new StaticConnectionPool(new []             //<1> list of ingest nodes
     {
         new Uri("http://ingestnode1:9200"),
         new Uri("http://ingestnode2:9200"),
         new Uri("http://ingestnode3:9200")
     });
     var settings       = new ConnectionSettings(pool);
     var indexingClient = new ElasticClient(settings);
 }
Example #27
0
        public void Usage()
        {
            var pool       = new StaticConnectionPool(new[] { new Node(new Uri("http://localhost:9200")) });
            var connection = new HttpConnection();
            var serializer = LowLevelRequestResponseSerializer.Instance;
            var product    = ElasticsearchProductRegistration.Default;

            var settings  = new TransportConfiguration(pool, connection, serializer, product);
            var transport = new Transport <TransportConfiguration>(settings);

            var response = transport.Request <StringResponse>(HttpMethod.GET, "/");
        }
Example #28
0
        public void UsesRelativePathForPing()
        {
            var pool     = new StaticConnectionPool(new[] { new Uri("http://localhost:9200/elasticsearch/") });
            var settings = new ConnectionSettings(pool,
                                                  new HttpConnectionTests.TestableHttpConnection(response =>
            {
                response.RequestMessage.RequestUri.AbsolutePath.Should().StartWith("/elasticsearch/");
            }));

            var client         = new ElasticClient(settings);
            var healthResponse = client.Ping();
        }
        public ElasticClient ElasticSearchClient()
        {
            var node = new Uri[]
            {
                new Uri("https://localhost:9200/"),
            };
            var connectionPool     = new StaticConnectionPool(node);
            var connectionSettings = new ConnectionSettings(connectionPool).DisableDirectStreaming();
            var elesticClient      = new ElasticClient(connectionSettings);

            return(elesticClient);
        }
Example #30
0
        private IElasticClient GetElasticClient()
        {
            var nodes = new List <Uri>
            {
                new Uri(elasticUrl)
            };

            var connectionPool     = new StaticConnectionPool(nodes);
            var connectionSettings = new ConnectionSettings(connectionPool);

            return(new ElasticClient(connectionSettings));
        }
        private IElasticClient CreatElasticClient()
        {
            var str            = _elasticSearchConfigration.ConnectionString;
            var strs           = str.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var nodes          = strs.Select(s => new Uri(s)).ToList();
            var connectionPool = new StaticConnectionPool(nodes);

            var settings = new ConnectionSettings(connectionPool)
                           .BasicAuthentication(_elasticSearchConfigration.AuthUserName, _elasticSearchConfigration.AuthPassWord);

            return(new ElasticClient(settings));
        }
        protected override void InitializeTarget()
        {
            base.InitializeTarget();

            var uri = GetConnectionString(ConnectionStringName) ?? Uri;
            var nodes = uri.Split(',').Select(url => new Uri(url));
            var connectionPool = new StaticConnectionPool(nodes);
            var config = new ConnectionConfiguration(connectionPool);
            _client = new ElasticsearchClient(config, serializer:ElasticsearchSerializer);

            if (!String.IsNullOrEmpty(ExcludedProperties))
                _excludedProperties = new List<string>(ExcludedProperties.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries));
        }
        protected override void InitializeTarget()
        {
            base.InitializeTarget();

            ConnectionStringSettings connectionStringSettings = null;
            if (!string.IsNullOrEmpty(ConnectionStringName))
                connectionStringSettings = ConfigurationManager.ConnectionStrings[ConnectionStringName];

            var uri = connectionStringSettings == null ? Uri : connectionStringSettings.ConnectionString;
            var nodes = uri.Split(',').Select(url => new Uri(url));
            var connectionPool = new StaticConnectionPool(nodes);
            var config = new ConnectionConfiguration(connectionPool);
            _client = new ElasticsearchClient(config, serializer:ElasticsearchSerializer);
        }
		public void StaticConnectionPool_ThrowsAndDoesNotRetry_On_401_Async()
		{
			var nodes = new Uri[] {
				new Uri("http://*****:*****@localhost:9200"),
				new Uri("http://*****:*****@localhost:9201")
			};
			var pool = new StaticConnectionPool(nodes);
			var settings = new ConnectionSettings(pool)
				.ThrowOnElasticsearchServerExceptions()
				.MaximumRetries(3);

			var client = new ElasticClient(settings);
			var e = Assert.Throws<ElasticsearchServerException>(async () => await client.RootNodeInfoAsync());
			e.Status.Should().Be(401);
		}
		public async void StaticConnectionPool_DoesNotThrowOrRetry_On_401_Async()
		{
			var nodes = new Uri[] {
				new Uri("http://*****:*****@localhost:9200"),
				new Uri("http://*****:*****@localhost:9201")
			};
			var pool = new StaticConnectionPool(nodes);
			var settings = new ConnectionSettings(pool)
				.MaximumRetries(3);
			var client = new ElasticClient(settings);
			var r = await client.RootNodeInfoAsync();
			r.IsValid.Should().BeFalse();
			r.ConnectionStatus.HttpStatusCode.Should().Be(401);
			r.ConnectionStatus.Metrics.Requests.Count.Should().Be(1);
			r.ConnectionStatus.Metrics.Requests[0].RequestType.Should().Be(RequestType.Ping);
			r.ConnectionStatus.NumberOfRetries.Should().Be(0);
		}
        /// <summary>
        /// Get the bulk connection pool of hosts
        /// </summary>
        /// <returns></returns>
        private ElasticClient getClient()
        {
            var nodes = new List<Uri>();
            foreach (var host in _hosts)
            {
                var url = string.Format("http://{0}:{1}", host, _port);
                nodes.Add(new Uri(url));
            }
            var pool = new StaticConnectionPool(nodes.ToArray());
            var settings = new ConnectionSettings(pool)
                .ExposeRawResponse();

            if (_disablePing)
                settings.DisablePing();
            else if (_pingTimeout != 0)
                settings.SetPingTimeout(_pingTimeout);

            var client = new ElasticClient(settings);
            return client;
        }
		public async void ConnectionPool_DoesNotThrowOnServerExceptions_ThrowsMaxRetryException_OnDeadNodes_Async()
		{
			var uris = new []
			{
				ElasticsearchConfiguration.CreateBaseUri(9201),
				ElasticsearchConfiguration.CreateBaseUri(9202),
				ElasticsearchConfiguration.CreateBaseUri(9203),
			};
			var connectionPool = new StaticConnectionPool(uris);
			var client = new ElasticClient(new ConnectionSettings(connectionPool)
				.SetTimeout(1000)
			);

			try
			{
				var result = await client.SearchAsync<ElasticsearchProject>(s => s.MatchAll());
				result.IsValid.Should().BeFalse();
			}
			catch (MaxRetryException)
			{
				Assert.Pass("MaxRetryException caught");
			}
			catch (Exception e)
			{
				Assert.Fail("Did not expect exception of type {0} to be caught", e.GetType().Name);
			}
		}
		public void ConnectionPool_DoesNotThrowOnServerExceptions_ThrowsMaxRetryException_OnDeadNodes()
		{
			var uris = new []
			{
				ElasticsearchConfiguration.CreateBaseUri(9201),
				ElasticsearchConfiguration.CreateBaseUri(9202),
				ElasticsearchConfiguration.CreateBaseUri(9203),
			};
			var connectionPool = new StaticConnectionPool(uris);
			var client = new ElasticClient(new ConnectionSettings(connectionPool)
				.SetTimeout(1000)
			);
			var e = Assert.Throws<MaxRetryException>(() =>
			{
				var result = client.Search<ElasticsearchProject>(s => s.MatchAll());
				result.IsValid.Should().BeFalse();
			});
			e.Should().NotBeNull();
		}
		public void ConnectionPool_ThrowOnServerExceptions_ThrowsElasticsearchServerException()
		{
			var uris = new []
			{
				ElasticsearchConfiguration.CreateBaseUri(9200),
				ElasticsearchConfiguration.CreateBaseUri(9200),
				ElasticsearchConfiguration.CreateBaseUri(9200),
			};
			var connectionPool = new StaticConnectionPool(uris);
			var client = new ElasticClient(new ConnectionSettings(connectionPool)
				.ThrowOnElasticsearchServerExceptions()
				.SetTimeout(1000)
			);
			var e = Assert.Throws<ElasticsearchServerException>(() =>
			{
				var index = ElasticsearchConfiguration.NewUniqueIndexName();
				var create = client.CreateIndex(index);
				var close = client.CloseIndex(index);
				var result = client.Search<ElasticsearchProject>(s => s.Index(index));
			});
			e.Should().NotBeNull();
		}
		public void ConnectionPool_SingleNode_PingExceptionThrowsMaxRetry_Async()
		{
			var uris = new []
			{
				ElasticsearchConfiguration.CreateBaseUri(9201),
			};
			var connectionPool = new StaticConnectionPool(uris);
			var client = new ElasticClient(new ConnectionSettings(connectionPool)
				.SetTimeout(1000)
			);
			var e = Assert.Throws<MaxRetryException>(async () =>
			{
				var result = await client.SearchAsync<ElasticsearchProject>(s => s
					.MatchAll()
				);
				result.IsValid.Should().BeFalse();
			});
			e.Should().NotBeNull();
		}
		public void Unauthorized_With_Ping_Disabled()
		{
			var nodes = new Uri[] {
				new Uri("http://*****:*****@localhost:9200"),
				new Uri("http://*****:*****@localhost:9201")
			};
			var pool = new StaticConnectionPool(nodes);
			var settings = new ConnectionSettings(pool)
				.MaximumRetries(3)
				.DisablePing();
			var client = new ElasticClient(settings);
			var r = client.RootNodeInfo();
			r.IsValid.Should().BeFalse();
			r.ConnectionStatus.HttpStatusCode.Should().Be(401);
			r.ConnectionStatus.Metrics.Requests.Count.Should().Be(1);
			r.ConnectionStatus.Metrics.Requests[0].RequestType.Should().Be(RequestType.ElasticsearchCall);
			r.ConnectionStatus.NumberOfRetries.Should().Be(0);
		}
		public void ConnectionPool_SingleNode_PingExceptionThrowsMaxRetry()
		{
			var uris = new []
			{
				ElasticsearchConfiguration.CreateBaseUri(9201),
			};
			var connectionPool = new StaticConnectionPool(uris);
			var client = new ElasticClient(new ConnectionSettings(connectionPool)
				.SetTimeout(1000)
				.MaximumRetries(1)
			);

			var e = Assert.Throws<MaxRetryException>(() => client.Search<ElasticsearchProject>(s => s.MatchAll()));
			e.Should().NotBeNull();
			Assert.Pass(e.ToString());
		}
        /// <summary>
        /// Get the bulk connection pool of hosts
        /// </summary>
        /// <returns></returns>
        private ElasticClient getClient()
        {
            var nodes = new List<Uri>();
            foreach (var host in _hosts)
            {
                var uri = ComposeUri(host, _port, _ssl, _username, _password);
                nodes.Add(uri);
            }
            var pool = new StaticConnectionPool(nodes.ToArray());
            var settings = new ConnectionSettings(pool)
                .ExposeRawResponse();

            if (_disablePing)
                settings.DisablePing();
            else if (_pingTimeout != 0)
                settings.SetPingTimeout(_pingTimeout);

            var client = new ElasticClient(settings);
            return client;
        }
		public async void ConnectionPool_ThrowOnServerExceptions_ThrowsElasticsearchServerException_Async()
		{
			var uris = new []
			{
				ElasticsearchConfiguration.CreateBaseUri(9200),
				ElasticsearchConfiguration.CreateBaseUri(9200),
				ElasticsearchConfiguration.CreateBaseUri(9200),
			};
			var connectionPool = new StaticConnectionPool(uris);
			var client = new ElasticClient(new ConnectionSettings(connectionPool)
				.ThrowOnElasticsearchServerExceptions()
				.SetTimeout(1000)
			);
			try
			{

				var index = ElasticsearchConfiguration.NewUniqueIndexName();
				var create = await client.CreateIndexAsync(i=>i.Index(index));
				var close = await client.CloseIndexAsync(i=>i.Index(index));
				var result = await client.SearchAsync<ElasticsearchProject>(s => s.Index(index));
			}
			catch (ElasticsearchServerException)
			{
				Assert.Pass("ElasticearchServerException caught");
			}
			catch (Exception e)
			{
				Assert.Fail("Did not expect exception of type {0} to be caught", e.GetType().Name);
			}
		}