#623 Elasticsearch.Net is now CLSCompliant

Author: Mpdreamz

src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj

@@ -80,6 +80,7 @@
     <Compile Include="Extensions.cs" />
     <Compile Include="Overrides\Descriptors\DeleteWarmerDescriptorOverrides.cs" />
     <Compile Include="Overrides\Descriptors\PutTemplateDescriptorOverrides.cs" />
+    <Compile Include="Overrides\Descriptors\ClearCacheDescriptorOverrides.cs" />
     <Compile Include="Overrides\Descriptors\SearchDescriptorOverrides.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

src/CodeGeneration/CodeGeneration.LowLevelClient/Overrides/Descriptors/ClearCacheDescriptorOverrides.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace CodeGeneration.LowLevelClient.Overrides.Descriptors
+{
+	public class ClearCacheDescriptorOverrides : IDescriptorOverrides
+	{
+		public IEnumerable<string> SkipQueryStringParams
+		{
+			get
+			{
+				return new string[]
+				{
+					"fielddata"
+				};
+			}
+		}
+	}
+}

src/Elasticsearch.Net/Connection/ElasticsearchResponseTracer.cs

@@ -11,7 +11,7 @@ public class ElasticsearchResponseTracer<T> : IDisposable
 		private readonly bool _enabled;
 		private Stopwatch _stopwatch;
 
-		public ElasticsearchResponse<T> _result { get; set; }
+		private ElasticsearchResponse<T> _result;
 
 		public ElasticsearchResponseTracer(bool enabled)
 		{

src/Elasticsearch.Net/Connection/HttpConnection.cs

@@ -9,16 +9,16 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Elasticsearch.Net.Providers;
-using PUrify;
+using PurifyNet;
 
 namespace Elasticsearch.Net.Connection
 {
 	public class HttpConnection : IConnection
 	{
 		const int BUFFER_SIZE = 1024;
 
-		protected IConnectionConfigurationValues _ConnectionSettings { get; set; }
-		private Semaphore _ResourceLock;
+		protected IConnectionConfigurationValues ConnectionSettings { get; set; }
+		private readonly Semaphore _resourceLock;
 		private readonly bool _enableTrace;
 
 		static HttpConnection()
@@ -33,11 +33,11 @@ public HttpConnection(IConnectionConfigurationValues settings)
 			if (settings == null)
 				throw new ArgumentNullException("settings");
 
-			this._ConnectionSettings = settings;
+			this.ConnectionSettings = settings;
 			if (settings.MaximumAsyncConnections > 0)
 			{
 				var semaphore = Math.Max(1, settings.MaximumAsyncConnections);
-				this._ResourceLock = new Semaphore(semaphore, semaphore);
+				this._resourceLock = new Semaphore(semaphore, semaphore);
 			}
 			this._enableTrace = settings.TraceEnabled;
 		}
@@ -137,11 +137,11 @@ protected virtual HttpWebRequest CreateHttpWebRequest(Uri uri, string method, by
 
 		private void SetProxyIfNeeded(HttpWebRequest myReq)
 		{
-			if (!string.IsNullOrEmpty(this._ConnectionSettings.ProxyAddress))
+			if (!string.IsNullOrEmpty(this.ConnectionSettings.ProxyAddress))
 			{
 				var proxy = new WebProxy();
-				var uri = new Uri(this._ConnectionSettings.ProxyAddress);
-				var credentials = new NetworkCredential(this._ConnectionSettings.ProxyUsername, this._ConnectionSettings.ProxyPassword);
+				var uri = new Uri(this.ConnectionSettings.ProxyAddress);
+				var credentials = new NetworkCredential(this.ConnectionSettings.ProxyUsername, this.ConnectionSettings.ProxyPassword);
 				proxy.Address = uri;
 				proxy.Credentials = credentials;
 				myReq.Proxy = proxy;
@@ -174,7 +174,7 @@ protected virtual HttpWebRequest CreateWebRequest(Uri uri, string method, byte[]
 				myReq.Accept = requestSpecificConfig.AcceptsContentType;
 				myReq.ContentType = requestSpecificConfig.AcceptsContentType;
 			}
-			var timeout = this._ConnectionSettings.Timeout;
+			var timeout = this.ConnectionSettings.Timeout;
 			myReq.Timeout = timeout; // 1 minute timeout.
 			myReq.ReadWriteTimeout = timeout; // 1 minute timeout.
 			myReq.Method = method;
@@ -226,32 +226,32 @@ private ElasticsearchResponse<Stream> HandleWebException(byte[] data, WebExcepti
 				cs = WebToElasticsearchResponse(data, httpEx.GetResponseStream(), httpEx, method, path);
 				return cs;
 			}
-			cs = ElasticsearchResponse<Stream>.CreateError(this._ConnectionSettings, webException, method, path, data);
+			cs = ElasticsearchResponse<Stream>.CreateError(this.ConnectionSettings, webException, method, path, data);
 			return cs;
 		}
 
 		private ElasticsearchResponse<Stream> WebToElasticsearchResponse(byte[] data, Stream responseStream, HttpWebResponse response, string method, string path)
 		{
-			ElasticsearchResponse<Stream> cs = ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, (int)response.StatusCode, method, path, data);
+			ElasticsearchResponse<Stream> cs = ElasticsearchResponse<Stream>.Create(this.ConnectionSettings, (int)response.StatusCode, method, path, data);
 			cs.Response = responseStream;
 			return cs;
 		}
 
 		protected virtual Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var tcs = new TaskCompletionSource<ElasticsearchResponse<Stream>>();
-			if (this._ConnectionSettings.MaximumAsyncConnections <= 0
-			  || this._ResourceLock == null)
+			if (this.ConnectionSettings.MaximumAsyncConnections <= 0
+			  || this._resourceLock == null)
 				return this.CreateIterateTask(request, data, requestSpecificConfig, tcs);
 
-			var timeout = this._ConnectionSettings.Timeout;
+			var timeout = this.ConnectionSettings.Timeout;
 			var path = request.RequestUri.ToString();
 			var method = request.Method;
-			if (!this._ResourceLock.WaitOne(timeout))
+			if (!this._resourceLock.WaitOne(timeout))
 			{
 				var m = "Could not start the operation before the timeout of " + timeout +
 				  "ms completed while waiting for the semaphore";
-				var cs = ElasticsearchResponse<Stream>.CreateError(this._ConnectionSettings, new TimeoutException(m), method, path, data);
+				var cs = ElasticsearchResponse<Stream>.CreateError(this.ConnectionSettings, new TimeoutException(m), method, path, data);
 				tcs.SetResult(cs);
 				return tcs.Task;
 			}
@@ -261,7 +261,7 @@ protected virtual Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequ
 			}
 			finally
 			{
-				this._ResourceLock.Release();
+				this._resourceLock.Release();
 			}
 		}
 
@@ -273,7 +273,7 @@ private Task<ElasticsearchResponse<Stream>> CreateIterateTask(HttpWebRequest req
 
 		private IEnumerable<Task> _AsyncSteps(HttpWebRequest request, TaskCompletionSource<ElasticsearchResponse<Stream>> tcs, byte[] data, object requestSpecificConfig)
 		{
-			var timeout = this._ConnectionSettings.Timeout;
+			var timeout = this.ConnectionSettings.Timeout;
 
 			var state = new ConnectionState { Connection = request };
 
@@ -309,7 +309,7 @@ private IEnumerable<Task> _AsyncSteps(HttpWebRequest request, TaskCompletionSour
 			//Since we expose the stream we let closing the stream determining when to close the connection
 			var response = (HttpWebResponse)getResponse.Result;
 			var responseStream = response.GetResponseStream();
-			var cs = ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, (int)response.StatusCode, method, path, data);
+			var cs = ElasticsearchResponse<Stream>.Create(this.ConnectionSettings, (int)response.StatusCode, method, path, data);
 			cs.Response = responseStream;
 			tcs.TrySetResult(cs);
 		}
@@ -332,7 +332,7 @@ public void Iterate<T>(HttpWebRequest request, byte[] data, IEnumerable<Task> as
 						var path = request.RequestUri.ToString();
 						var method = request.Method;
 
-						var response = ElasticsearchResponse<T>.CreateError(this._ConnectionSettings, exception, method, path, data);
+						var response = ElasticsearchResponse<T>.CreateError(this.ConnectionSettings, exception, method, path, data);
 						tcs.SetResult(response);
 					}
 					else

src/Elasticsearch.Net/Connection/InMemoryConnection.cs

@@ -33,7 +33,7 @@ private ElasticsearchResponse<Stream> ReturnConnectionStatus(HttpWebRequest requ
 			var method = request.Method;
 			var path = request.RequestUri.ToString();
 
-			var cs = ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, 200, method, path, data);
+			var cs = ElasticsearchResponse<Stream>.Create(this.ConnectionSettings, 200, method, path, data);
 			cs.Response = new MemoryStream(_fixedResultBytes);
 			return cs;
 		}

src/Elasticsearch.Net/Connection/Transport.cs

@@ -12,22 +12,22 @@
 using Elasticsearch.Net.Exceptions;
 using Elasticsearch.Net.Providers;
 using Elasticsearch.Net.Serialization;
-using PUrify;
+using PurifyNet;
 
 namespace Elasticsearch.Net.Connection
 {
 	public class Transport : ITransport
 	{
 		protected static readonly string MaxRetryExceptionMessage = "Unable to perform request: '{0} {1}' on any of the nodes after retrying {2} times.";
-		protected internal readonly IConnectionConfigurationValues _configurationValues;
-		protected internal readonly IConnection _connection;
-		protected internal readonly IElasticsearchSerializer _serializer;
+		protected internal readonly IConnectionConfigurationValues ConfigurationValues;
+		protected internal readonly IConnection Connection;
+		private readonly IElasticsearchSerializer _serializer;
 
 		private readonly IConnectionPool _connectionPool;
 		private readonly IDateTimeProvider _dateTimeProvider;
 		private DateTime? _lastSniff;
 
-		public IConnectionConfigurationValues Settings { get { return _configurationValues; } }
+		public IConnectionConfigurationValues Settings { get { return ConfigurationValues; } }
 		public IElasticsearchSerializer Serializer { get { return _serializer; } }
 
 		public Transport(
@@ -37,10 +37,10 @@ public Transport(
 			IDateTimeProvider dateTimeProvider = null
 			)
 		{
-			this._configurationValues = configurationValues;
-			this._connection = connection ?? new HttpConnection(configurationValues);
+			this.ConfigurationValues = configurationValues;
+			this.Connection = connection ?? new HttpConnection(configurationValues);
 			this._serializer = serializer ?? new ElasticsearchDefaultSerializer();
-			this._connectionPool = this._configurationValues.ConnectionPool;
+			this._connectionPool = this.ConfigurationValues.ConnectionPool;
 
 			this._dateTimeProvider = dateTimeProvider ?? new DateTimeProvider();
 
@@ -58,7 +58,7 @@ public virtual bool Ping(Uri baseUri)
 			var requestOverrides = new RequestConnectionConfiguration()
 				.ConnectTimeout(pingTimeout)
 				.RequestTimeout(pingTimeout);
-			var response = this._connection.HeadSync(CreateUriToPath(baseUri, ""), requestOverrides);
+			var response = this.Connection.HeadSync(CreateUriToPath(baseUri, ""), requestOverrides);
 			if (response.Response == null) return false;
 			using(response.Response)
 				return response.Success;
@@ -71,7 +71,7 @@ public virtual Task<bool> PingAsync(Uri baseUri)
 				.ConnectTimeout(pingTimeout)
 				.RequestTimeout(pingTimeout);
 
-			return this._connection.Head(CreateUriToPath(baseUri, ""), requestOverrides)
+			return this.Connection.Head(CreateUriToPath(baseUri, ""), requestOverrides)
 				.ContinueWith(t=>
 				{
 					var response = t.Result;
@@ -123,7 +123,7 @@ public virtual void SniffClusterState()
 
 		private void SniffIfInformationIsTooOld(int retried)
 		{
-			var sniffLifeSpan = this._configurationValues.SniffInformationLifeSpan;
+			var sniffLifeSpan = this.ConfigurationValues.SniffInformationLifeSpan;
 			var now = this._dateTimeProvider.Now();
 			if (retried == 0 && this._lastSniff.HasValue &&
 				sniffLifeSpan.HasValue && sniffLifeSpan.Value < (now - this._lastSniff.Value))
@@ -140,7 +140,7 @@ private int GetMaximumRetries(IRequestConfiguration requestConfiguration)
 			if (requestConfiguration != null && requestConfiguration.MaxRetries.HasValue)
 				return requestConfiguration.MaxRetries.Value;
 
-			return this._configurationValues.MaxRetries.GetValueOrDefault(this._connectionPool.MaxRetries);
+			return this.ConfigurationValues.MaxRetries.GetValueOrDefault(this._connectionPool.MaxRetries);
 		}
 
 		private bool SniffingDisabled(IRequestConfiguration requestConfiguration)
@@ -183,7 +183,7 @@ private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestSt
 			try
 			{
 				if (shouldPingHint 
-					&& !this._configurationValues.DisablePings
+					&& !this.ConfigurationValues.DisablePings
 					&& (requestState.RequestConfiguration == null
 						|| !requestState.RequestConfiguration.PingDisabled.GetValueOrDefault(false))
 					)
@@ -249,10 +249,10 @@ private ElasticsearchResponse<T> RetryRequest<T>(TransportRequestState<T> reques
 			var maxRetries = this.GetMaximumRetries(requestState.RequestConfiguration);
 			var exceptionMessage = MaxRetryExceptionMessage.F(requestState.Method, requestState.Path.IsNullOrEmpty() ? "/" : "", retried);
 
-			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
+			this._connectionPool.MarkDead(baseUri, this.ConfigurationValues.DeadTimeout, this.ConfigurationValues.MaxDeadTimeout);
 
 			if (!SniffingDisabled(requestState.RequestConfiguration)
-				&& this._configurationValues.SniffsOnConnectionFault 
+				&& this.ConfigurationValues.SniffsOnConnectionFault 
 				&& retried == 0)
 				this.SniffClusterState();
 
@@ -265,14 +265,14 @@ private ElasticsearchResponse<Stream> _doRequest(string method, Uri uri, byte[]
 		{
 			switch (method.ToLowerInvariant())
 			{
-				case "post": return this._connection.PostSync(uri, postData, requestSpecificConfig);
-				case "put": return this._connection.PutSync(uri, postData, requestSpecificConfig);
-				case "head": return this._connection.HeadSync(uri, requestSpecificConfig);
-				case "get": return this._connection.GetSync(uri, requestSpecificConfig);
+				case "post": return this.Connection.PostSync(uri, postData, requestSpecificConfig);
+				case "put": return this.Connection.PutSync(uri, postData, requestSpecificConfig);
+				case "head": return this.Connection.HeadSync(uri, requestSpecificConfig);
+				case "get": return this.Connection.GetSync(uri, requestSpecificConfig);
 				case "delete":
 					return postData == null || postData.Length == 0
-						? this._connection.DeleteSync(uri, requestSpecificConfig)
-						: this._connection.DeleteSync(uri, postData, requestSpecificConfig);
+						? this.Connection.DeleteSync(uri, requestSpecificConfig)
+						: this.Connection.DeleteSync(uri, postData, requestSpecificConfig);
 			}
 			throw new Exception("Unknown HTTP method " + method);
 		}
@@ -310,7 +310,7 @@ private Task<ElasticsearchResponse<T>> DoRequestAsync<T>(TransportRequestState<T
 
 			var uri = CreateUriToPath(baseUri, requestState.Path);
 
-			if (shouldPingHint && !this._configurationValues.DisablePings)
+			if (shouldPingHint && !this.ConfigurationValues.DisablePings)
 			{
 				return this.PingAsync(baseUri)
 					.ContinueWith(t =>
@@ -351,9 +351,9 @@ private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(TransportRequestStat
 			var maxRetries = this.GetMaximumRetries(requestState.RequestConfiguration);
 			var exceptionMessage = MaxRetryExceptionMessage.F(requestState.Method, requestState.Path, retried);
 
-			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
+			this._connectionPool.MarkDead(baseUri, this.ConfigurationValues.DeadTimeout, this.ConfigurationValues.MaxDeadTimeout);
 
-			if (this._configurationValues.SniffsOnConnectionFault && retried == 0)
+			if (this.ConfigurationValues.SniffsOnConnectionFault && retried == 0)
 				this.SniffClusterState();
 
 			if (retried < maxRetries)
@@ -366,14 +366,14 @@ private Task<ElasticsearchResponse<Stream>> _doRequestAsync(string method, Uri u
 		{
 			switch (method.ToLowerInvariant())
 			{
-				case "head": return this._connection.Head(uri, requestSpecificConfig);
-				case "get": return this._connection.Get(uri, requestSpecificConfig);
-				case "post": return this._connection.Post(uri, postData, requestSpecificConfig);
-				case "put": return this._connection.Put(uri, postData, requestSpecificConfig);
+				case "head": return this.Connection.Head(uri, requestSpecificConfig);
+				case "get": return this.Connection.Get(uri, requestSpecificConfig);
+				case "post": return this.Connection.Post(uri, postData, requestSpecificConfig);
+				case "put": return this.Connection.Put(uri, postData, requestSpecificConfig);
 				case "delete":
 					return postData == null || postData.Length == 0
-						? this._connection.Delete(uri, requestSpecificConfig)
-						: this._connection.Delete(uri, postData, requestSpecificConfig);
+						? this.Connection.Delete(uri, requestSpecificConfig)
+						: this.Connection.Delete(uri, postData, requestSpecificConfig);
 			}
 			throw new Exception("Unknown HTTP method " + method);
 		}

src/Elasticsearch.Net/ConnectionPool/EndpointState.cs

@@ -7,7 +7,7 @@ namespace Elasticsearch.Net.ConnectionPool
 {
 	public class EndpointState
 	{
-		public int _attempts = -1;
-		public DateTime date = new DateTime();
+		public int Attemps = -1;
+		public DateTime Date = new DateTime();
 	}
 }

src/Elasticsearch.Net/ConnectionPool/SniffingConnectionPool.cs

@@ -11,8 +11,6 @@ public class SniffingConnectionPool : StaticConnectionPool
 	{
 		private readonly ReaderWriterLockSlim _readerWriter = new ReaderWriterLockSlim();
 
-		private bool _seenStartup = false;
-
 		public override bool AcceptsUpdates { get { return true; } }
 
 		public SniffingConnectionPool(
@@ -25,14 +23,11 @@ public SniffingConnectionPool(
 
 		public override void UpdateNodeList(IList<Uri> newClusterState, bool fromStartupHint = false)
 		{
-			if (fromStartupHint)
-				this._seenStartup = true;
-
 			try
 			{
 				this._readerWriter.EnterWriteLock();
-				this._nodeUris = newClusterState;
-				this._uriLookup = newClusterState.ToDictionary(k => k, v => new EndpointState());
+				this.NodeUris = newClusterState;
+				this.UriLookup = newClusterState.ToDictionary(k => k, v => new EndpointState());
 			}
 			finally
 			{