Merge branch 'master' of github.com:elastic/elasticsearch-net

Author: Mpdreamz

src/Elasticsearch.Net/Configuration/ConnectionConfiguration.cs

@@ -3,7 +3,7 @@
 using System.ComponentModel;
 
 namespace Elasticsearch.Net
-{
+{
 	/// <summary>
 	/// ConnectionConfiguration allows you to control how ElasticsearchClient behaves and where/how it connects 
 	/// to elasticsearch
@@ -12,40 +12,40 @@ public class ConnectionConfiguration : ConnectionConfiguration<ConnectionConfigu
 	{
 		public static TimeSpan DefaultTimeout = TimeSpan.FromMinutes(1);
 		public static TimeSpan DefaultPingTimeout = TimeSpan.FromSeconds(2);
-		public static TimeSpan DefaultPingTimeoutOnSSL = TimeSpan.FromSeconds(5);
-
+		public static TimeSpan DefaultPingTimeoutOnSSL = TimeSpan.FromSeconds(5);
+
 		/// <summary>
 		/// ConnectionConfiguration allows you to control how ElasticsearchClient behaves and where/how it connects 
 		/// to elasticsearch
 		/// </summary>
 		/// <param name="uri">The root of the elasticsearch node we want to connect to. Defaults to http://localhost:9200</param>
 		public ConnectionConfiguration(Uri uri = null)
-			: this(new SingleNodeConnectionPool(uri ?? new Uri("http://localhost:9200")))
-		{ }
-
+			: this(new SingleNodeConnectionPool(uri ?? new Uri("http://localhost:9200")))
+		{ }
+
 		/// <summary>
 		/// ConnectionConfiguration allows you to control how ElasticsearchClient behaves and where/how it connects 
 		/// to elasticsearch
 		/// </summary>
 		/// <param name="connectionPool">A connection pool implementation that'll tell the client what nodes are available</param>
-		public ConnectionConfiguration(IConnectionPool connectionPool)
-			// ReSharper disable once IntroduceOptionalParameters.Global 
-			: this(connectionPool, null, null)
+		public ConnectionConfiguration(IConnectionPool connectionPool)
+			// ReSharper disable once IntroduceOptionalParameters.Global 
+			: this(connectionPool, null, null)
 		{ }
 
-		public ConnectionConfiguration(IConnectionPool connectionPool, IConnection connection)
-			// ReSharper disable once IntroduceOptionalParameters.Global
-			: this(connectionPool, connection, null)
+		public ConnectionConfiguration(IConnectionPool connectionPool, IConnection connection)
+			// ReSharper disable once IntroduceOptionalParameters.Global
+			: this(connectionPool, connection, null)
 		{ }
 
 		public ConnectionConfiguration(IConnectionPool connectionPool, IElasticsearchSerializer serializer)
-			: this(connectionPool, null, serializer)
-		{ }
-
-		// ReSharper disable once MemberCanBePrivate.Global
-		// eventhough we use don't use this we very much would like to  expose this constructor
+			: this(connectionPool, null, serializer)
+		{ }
+
+		// ReSharper disable once MemberCanBePrivate.Global
+		// eventhough we use don't use this we very much would like to  expose this constructor
 		public ConnectionConfiguration(IConnectionPool connectionPool, IConnection connection, IElasticsearchSerializer serializer)
-			: base(connectionPool, connection, serializer)
+			: base(connectionPool, connection, serializer)
 		{ }
 	}
 
@@ -111,8 +111,8 @@ public abstract class ConnectionConfiguration<T> : IConnectionConfigurationValue
 		private bool _enableHttpCompression;
 		bool IConnectionConfigurationValues.EnableHttpCompression => _enableHttpCompression;
 
-		private bool _httpPipeliningEnabled = true;
-		bool IConnectionConfigurationValues.HttpPipeliningEnabled => _httpPipeliningEnabled;
+		private bool _enableHttpPipelining = true;
+		bool IConnectionConfigurationValues.HttpPipeliningEnabled => _enableHttpPipelining;
 
 		private bool _throwExceptions;
 		bool IConnectionConfigurationValues.ThrowExceptions => _throwExceptions;
@@ -140,13 +140,13 @@ private static void DefaultApiCallHandler(IApiCallDetails status) { }
 		IConnection IConnectionConfigurationValues.Connection => _connection;
 
 		[System.Diagnostics.CodeAnalysis.SuppressMessage(
-			"Potential Code Quality Issues", "RECS0021:Warns about calls to virtual member functions occuring in the constructor",
+			"Potential Code Quality Issues", "RECS0021:Warns about calls to virtual member functions occuring in the constructor",
 			Justification = "We want the virtual method to run on most derived")]
 		protected ConnectionConfiguration(IConnectionPool connectionPool, IConnection connection, IElasticsearchSerializer serializer)
 		{
 			this._connectionPool = connectionPool;
-			this._connection = connection ?? new HttpConnection();
-			// ReSharper disable once VirtualMemberCallInContructor
+			this._connection = connection ?? new HttpConnection();
+			// ReSharper disable once VirtualMemberCallInContructor
 			this._serializer = serializer ?? this.DefaultSerializer();
 
 			this._requestTimeout = ConnectionConfiguration.DefaultTimeout;
@@ -162,95 +162,95 @@ protected ConnectionConfiguration(IConnectionPool connectionPool, IConnection co
 		public T EnableTcpKeepAlive(TimeSpan keepAliveTime, TimeSpan keepAliveInterval) =>
 			Assign(a => { this._keepAliveTime = keepAliveTime; this._keepAliveInterval = keepAliveInterval; });
 
-		public T MaximumRetries(int maxRetries) => Assign(a => a._maxRetries = maxRetries);
-
+		public T MaximumRetries(int maxRetries) => Assign(a => a._maxRetries = maxRetries);
+
 		/// <summary>
 		/// On connection pools that support reseeding setting this to true (default) will resniff the cluster when a call fails
 		/// </summary>
-		public T SniffOnConnectionFault(bool sniffsOnConnectionFault = true) => Assign(a => a._sniffOnConnectionFault = sniffsOnConnectionFault);
-
+		public T SniffOnConnectionFault(bool sniffsOnConnectionFault = true) => Assign(a => a._sniffOnConnectionFault = sniffsOnConnectionFault);
+
 		/// <summary>
 		/// Enables sniffing on first usage of a connection pool if that pool supports reseeding, defaults to true
 		/// </summary>
-		public T SniffOnStartup(bool sniffsOnStartup = true) => Assign(a => a._sniffOnStartup = sniffsOnStartup);
-
+		public T SniffOnStartup(bool sniffsOnStartup = true) => Assign(a => a._sniffOnStartup = sniffsOnStartup);
+
 		/// <summary>
 		/// Set the duration after which a cluster state is considered stale and a sniff should be performed again.
 		/// An IConnectionPool has to signal it supports reseeding otherwise sniffing will never happen.
 		/// Defaults to 1 hour.
 		/// Set to null to disable completely. Sniffing will only ever happen on ConnectionPools that return true for SupportsReseeding
 		/// </summary>
 		/// <param name="sniffLifeSpan">The duration a clusterstate is considered fresh, set to null to disable periodic sniffing</param>
-		public T SniffLifeSpan(TimeSpan? sniffLifeSpan) => Assign(a => a._sniffLifeSpan = sniffLifeSpan);
-
+		public T SniffLifeSpan(TimeSpan? sniffLifeSpan) => Assign(a => a._sniffLifeSpan = sniffLifeSpan);
+
 		/// <summary>
 		/// Enable gzip compressed requests and responses, do note that you need to configure elasticsearch to set this
 		/// <para>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-http.html"</para>
 		/// </summary>
 		public T EnableHttpCompression(bool enabled = true) => Assign(a => a._enableHttpCompression = enabled);
 
-		public T DisableAutomaticProxyDetection(bool disable = true) => Assign(a => a._disableAutomaticProxyDetection = disable);
-
+		public T DisableAutomaticProxyDetection(bool disable = true) => Assign(a => a._disableAutomaticProxyDetection = disable);
+
 		/// <summary>
 		/// Instead of following a c/go like error checking on response.IsValid always throw an exception
 		/// on the client when a call resulted in an exception on either the client or the Elasticsearch server. 
 		/// <para>Reasons for such exceptions could be search parser errors, index missing exceptions, etc...</para>
 		/// </summary>
-		public T ThrowExceptions(bool alwaysThrow = true) => Assign(a => a._throwExceptions = alwaysThrow);
-
+		public T ThrowExceptions(bool alwaysThrow = true) => Assign(a => a._throwExceptions = alwaysThrow);
+
 		/// <summary>
 		/// When a node is used for the very first time or when it's used for the first time after it has been marked dead
 		/// a ping with a very low timeout is send to the node to make sure that when it's still dead it reports it as fast as possible.
 		/// You can disable these pings globally here if you rather have it fail on the possible slower original request
 		/// </summary>
-		public T DisablePing(bool disable = true) => Assign(a => a._disablePings = disable);
-
+		public T DisablePing(bool disable = true) => Assign(a => a._disablePings = disable);
+
 		/// <summary>
 		/// This NameValueCollection will be appended to every url NEST calls, great if you need to pass i.e an API key.
 		/// </summary>
-		public T GlobalQueryStringParameters(NameValueCollection queryStringParameters) => Assign(a => a._queryString.Add(queryStringParameters));
-
+		public T GlobalQueryStringParameters(NameValueCollection queryStringParameters) => Assign(a => a._queryString.Add(queryStringParameters));
+
 		/// <summary>
 		/// a NameValueCollection that will be send as headers for each request
 		/// </summary>
-		public T GlobalHeaders(NameValueCollection headers) => Assign(a => a._headers.Add(headers));
-
+		public T GlobalHeaders(NameValueCollection headers) => Assign(a => a._headers.Add(headers));
+
 		/// <summary>
 		/// Sets the default timeout in milliseconds for each request to Elasticsearch.
 		/// NOTE: You can set this to a high value here, and specify the timeout on Elasticsearch's side.
 		/// </summary>
 		/// <param name="timeout">time out in milliseconds</param>
-		public T RequestTimeout(TimeSpan timeout) => Assign(a => a._requestTimeout = timeout);
-
+		public T RequestTimeout(TimeSpan timeout) => Assign(a => a._requestTimeout = timeout);
+
 		/// <summary>
 		/// Sets the default ping timeout in milliseconds for ping requests, which are used
 		/// to determine whether a node is alive. Pings should fail as fast as possible.
 		/// </summary>
 		/// <param name="timeout">The ping timeout in milliseconds defaults to 1000, or 2000 is using SSL.</param>
-		public T PingTimeout(TimeSpan timeout) => Assign(a => a._pingTimeout = timeout);
-
+		public T PingTimeout(TimeSpan timeout) => Assign(a => a._pingTimeout = timeout);
+
 		/// <summary>
 		/// Sets the default dead timeout factor when a node has been marked dead.
 		/// </summary>
 		/// <remarks>Some connection pools may use a flat timeout whilst others take this factor and increase it exponentially</remarks>
 		/// <param name="timeout"></param>
-		public T DeadTimeout(TimeSpan timeout) => Assign(a => a._deadTimeout = timeout);
-
+		public T DeadTimeout(TimeSpan timeout) => Assign(a => a._deadTimeout = timeout);
+
 		/// <summary>
 		/// Sets the maximum time a node can be marked dead. 
 		/// Different implementations of IConnectionPool may choose a different default.
 		/// </summary>
 		/// <param name="timeout">The timeout in milliseconds</param>
-		public T MaxDeadTimeout(TimeSpan timeout) => Assign(a => a._maxDeadTimeout = timeout);
-
+		public T MaxDeadTimeout(TimeSpan timeout) => Assign(a => a._maxDeadTimeout = timeout);
+
 		/// <summary>
 		/// Limits the total runtime including retries separately from <see cref="RequestTimeout"/>
 		/// <pre>
 		/// When not specified defaults to <see cref="RequestTimeout"/> which itself defaults to 60seconds
 		/// </pre>
 		/// </summary>
-		public T MaxRetryTimeout(TimeSpan maxRetryTimeout) => Assign(a => a._maxRetryTimeout = maxRetryTimeout);
-
+		public T MaxRetryTimeout(TimeSpan maxRetryTimeout) => Assign(a => a._maxRetryTimeout = maxRetryTimeout);
+
 		/// <summary>
 		/// If your connection has to go through proxy use this method to specify the proxy url
 		/// </summary>
@@ -261,33 +261,33 @@ public T Proxy(Uri proxyAdress, string username, string password)
 			this._proxyUsername = username;
 			this._proxyPassword = password;
 			return (T)this;
-		}
-
+		}
+
 		/// <summary>
 		/// Forces all requests to have ?pretty=true, causing elasticsearch to return formatted json. 
 		/// Also forces the client to send out formatted json. Defaults to false
 		/// </summary>
-		public T PrettyJson(bool b = true) => Assign(a =>
+		public T PrettyJson(bool b = true) => Assign(a =>
 		{
 			this._prettyJson = b;
 			if (!b && this._queryString["pretty"] != null) this._queryString.Remove("pretty");
 			else if (b && this._queryString["pretty"] == null)
-				this.GlobalQueryStringParameters(new NameValueCollection { { "pretty", b.ToString().ToLowerInvariant() } });
-		});
-
+				this.GlobalQueryStringParameters(new NameValueCollection { { "pretty", b.ToString().ToLowerInvariant() } });
+		});
+
 		/// <summary>
 		/// Make sure the reponse bytes are always available on the ElasticsearchResponse object
 		/// <para>Note: that depending on the registered serializer this may cause the respond to be read in memory first</para>
 		/// </summary>
-		public T DisableDirectStreaming(bool b = true) => Assign(a => a._disableDirectStreaming = b);
-
+		public T DisableDirectStreaming(bool b = true) => Assign(a => a._disableDirectStreaming = b);
+
 		/// <summary>
 		/// Global callback for every response that NEST receives, useful for custom logging.
 		/// Calling this multiple times will register multiple listeners
 		/// </summary>
 		public T ConnectionStatusHandler(Action<IApiCallDetails> handler) =>
-			Assign(a => a._apiCallHandler += handler ?? DefaultApiCallHandler);
-
+			Assign(a => a._apiCallHandler += handler ?? DefaultApiCallHandler);
+
 		/// <summary>
 		/// Basic access authentication credentials to specify with all requests.
 		/// </summary>
@@ -299,13 +299,13 @@ public T BasicAuthentication(string userName, string password)
 				Password = password
 			};
 			return (T)this;
-		}
-
+		}
+
 		/// <summary>
 		/// Allows for requests to be pipelined. http://en.wikipedia.org/wiki/HTTP_pipelining
 		/// <para>Note: HTTP pipelining must also be enabled in Elasticsearch for this to work properly.</para>
 		/// </summary>
-		public T HttpPipeliningEnabled(bool enabled = true) => Assign(a => a._httpPipeliningEnabled = enabled);
+		public T EnableHttpPipelining(bool enabled = true) => Assign(a => a._enableHttpPipelining = enabled);
 	}
 }
 

src/Elasticsearch.Net/Responses/ElasticsearchResponse.cs

@@ -9,7 +9,7 @@ internal static class ResponseStatics
 	{
 		public static readonly string PrintFormat = "StatusCode: {1}, {0}\tMethod: {2}, {0}\tUrl: {3}, {0}\tRequest: {4}, {0}\tResponse: {5}";
 		public static readonly string ErrorFormat = "{0}\tExceptionMessage: {1}{0}\t StackTrace: {2}";
-		public static readonly string AlreadyCaptured = "<Response stream not captured or already read to completion by serializer, set ExposeRawResponse() on connectionsettings to force it to be set on>";
+		public static readonly string AlreadyCaptured = "<Response stream not captured or already read to completion by serializer. Set DisableDirectStreaming() on ConnectionSettings to force it to be set on the response.>";
 	}
 
 	public class ElasticsearchResponse<T> : IApiCallDetails

src/Nest/Search/Search/SearchResponse.cs

@@ -13,7 +13,7 @@ public interface ISearchResponse<T> : IResponse where T : class
 		IDictionary<string, IAggregation> Aggregations { get; }
 		AggregationsHelper Aggs { get; }
 		IDictionary<string, Suggest[]> Suggest { get; }
-		int ElapsedMilliseconds { get; }
+		int Took { get; }
 		bool TimedOut { get; }
 		bool TerminatedEarly { get; }
 		string ScrollId { get; }
@@ -40,7 +40,7 @@ public interface ISearchResponse<T> : IResponse where T : class
 	[JsonObject]
 	public class SearchResponse<T> : BaseResponse, ISearchResponse<T> where T : class
 	{
-		internal ServerError MultiSearchError { get; set; }
+		internal ServerError MultiSearchError { get; set; }
 		public override IApiCallDetails ApiCall => MultiSearchError != null ? new ApiCallDetailsOverride(base.ApiCall, MultiSearchError) : base.ApiCall;
 
 		[JsonProperty(PropertyName = "_shards")]
@@ -64,7 +64,7 @@ public AggregationsHelper Aggs
 		public IDictionary<string, Suggest[]> Suggest { get; internal set; }
 
 		[JsonProperty(PropertyName = "took")]
-		public int ElapsedMilliseconds { get; internal set; }
+		public int Took { get; internal set; }
 
 		[JsonProperty("timed_out")]
 		public bool TimedOut { get; internal set; }

src/Tests/Search/Search/SearchApiTests.cs

@@ -64,6 +64,7 @@ protected override void ExpectResponse(ISearchResponse<Project> response)
 			response.Hits.First().Should().NotBeNull();
 			response.Hits.First().Source.Should().NotBeNull();
 			response.Aggregations.Count.Should().BeGreaterThan(0);
+			response.Took.Should().BeGreaterThan(0);
 			var startDates = response.Aggs.Terms("startDates");
 			startDates.Should().NotBeNull();
 		}