/** == SniffingConnectionPool 
		* A subclass of StaticConnectionPool that allows itself to be reseeded at run time.
		* It comes with a very minor overhead of a ReaderWriterLock to ensure thread safety.
		*/
		[U] public void Sniffing()
		{
			var uris = Enumerable.Range(9200, 5).Select(p => new Uri("http://localhost:" + p));

			/** a connection pool can be seeded using an enumerable of `Uri` */
			var pool = new SniffingConnectionPool(uris);

			/** Or using an enumerable of `Node`
			* A major benefit here is you can include known node roles when seeding 
			* NEST can use this information to favour sniffing on master eligable nodes first
			* and take master only nodes out of rotation for issueing client calls on.
			*/
			var nodes = uris.Select(u=>new Node(u));
			pool = new SniffingConnectionPool(nodes);

			/** This type of pool is hardwirted to optout out sniffing*/
			pool.SupportsReseeding.Should().BeTrue();

			/** but supports pinging when enabled */
			pool.SupportsPinging.Should().BeTrue();

			/** To create a client using this siffing connection pool pass 
			* the connection pool to the connectionsettings you pass to ElasticClient
			*/
			var client = new ElasticClient(new ConnectionSettings(pool));
			client.ConnectionSettings.ConnectionPool.Should().BeOfType<SniffingConnectionPool>();
		}
		/** 
		 * This however is still 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 `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 ElasticsearchClient(config);
		}
예제 #3
0
        private void ApplySettings(dynamic config)
        {
            _clients.Clear();
            _config = (ESConfig)(config?.elasticsearch?.ToObject <ESConfig>()) ?? new ESConfig();

            _connectionPools = _config.ConnectionPools?.ToDictionary(kvp => kvp.Key, kvp =>
            {
                var c = kvp.Value;
                IConnectionPool pool;
                var endpoints = c.Endpoints.DefaultIfEmpty("http://localhost:9200").Select(endpoint => new Uri(endpoint));
                if (c.Sniffing)
                {
                    //      var connectionEndpoints = ((JArray)config.esEndpoints).ToObject<string[]>();
                    pool = new Elasticsearch.Net.SniffingConnectionPool(endpoints);
                }
                else
                {
                    pool = new Elasticsearch.Net.StaticConnectionPool(endpoints);
                }
                return(new ConnectionPool(pool, c.Credentials));
            }) ?? new Dictionary <string, ConnectionPool>();

            if (!_connectionPools.ContainsKey("default"))
            {
                _connectionPools.Add("default", new ConnectionPool(new Elasticsearch.Net.StaticConnectionPool(new[] { new Uri("http://localhost:9200") }), null));
            }
        }
		[U] public void SniffingPoolWithstandsConcurrentReadAndWrites()
		{
			var uris = Enumerable.Range(9200, NumberOfNodes).Select(p => new Uri("http://localhost:" + p));
			var sniffingPool = new SniffingConnectionPool(uris, randomize: false);

			Action callSniffing = () => this.AssertCreateView(sniffingPool);

			callSniffing.ShouldNotThrow();
		}
예제 #5
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);
		}
예제 #6
0
		/**
		 * Here instead of directly passing `node`, we pass a <<sniffing-connection-pool, SniffingConnectionPool>>
		 * which will use our `node` to find out the rest of the available cluster nodes.
		 * Be sure to read more about <<connection-pooling, Connection Pooling and Cluster Failover>>.
		 *
		 * === Configuration Options
		 *
		 *Besides either passing a `Uri` or `IConnectionPool` to `ConnectionConfiguration`, you can also fluently control many more options. For instance:
		 */
		public void SpecifyingClientOptions()
		{
			var node = new Uri("http://mynode.example.com:8082/apiKey");
			var connectionPool = new SniffingConnectionPool(new[] { node });

			var config = new ConnectionConfiguration(connectionPool)
				.DisableDirectStreaming() //<1> Additional options are fluent method calls on `ConnectionConfiguration`
				.BasicAuthentication("user", "pass")
				.RequestTimeout(TimeSpan.FromSeconds(5));
		}
		/** 
		 * Here instead of directly passing `node`, we pass a `SniffingConnectionPool` which will use our `node` to find out the rest of the available cluster nodes.
		 * Be sure to read more about [Connection Pooling and Cluster Failover here](/elasticsearch-net/cluster-failover.html)
		 * 
		 * ## Options
		 * 
		 *  Besides either passing a `Uri` or `IConnectionPool` to `ConnectionConfiguration`, you can also fluently control many more options. For instance:
		 */

		public void SpecifyingClientOptions()
		{
			//hide
			var node = new Uri("http://mynode.example.com:8082/apiKey");
			var connectionPool = new SniffingConnectionPool(new[] { node });
			//endhide

			var config = new ConnectionConfiguration(connectionPool)
				.DisableDirectStreaming()
				.BasicAuthentication("user", "pass")
				.RequestTimeout(TimeSpan.FromSeconds(5));

		}
예제 #8
0
		protected ConnectionSettings CreateSettings()
		{
			var host = Process.GetProcessesByName("fiddler").Any() 
				? "ipv4.fiddler"
				: "localhost";

			var uri = new UriBuilder("http", host, Port).Uri;
			var connectionPool = new SniffingConnectionPool(new [] { uri });

			return new ConnectionSettings(connectionPool)
				.SetDefaultIndex(IndexName)
				.SniffOnStartup()
				.ThrowExceptions();
		}
        public ElasticClient CreateEsClient()
        {
            var nodeUri = new Uri(_elasticSearchUrl);

            var connectionPool = new SniffingConnectionPool(new[] { nodeUri });

            var connectionSettings = new ConnectionSettings(connectionPool)
                .MapDefaultTypeIndices(m =>
                    m.Add(typeof(KundeIndexItem), "kunder")
                );

            var esClient = new ElasticClient(connectionSettings);

            return esClient;
        }