Merge branch 'fix/serialization-overrides'

Conflicts:
	src/Elasticsearch.Net/Configuration/ConnectionConfiguration.cs

Author: Mpdreamz

Diff for: src/Elasticsearch.Net/Configuration/ConnectionConfiguration.cs

@@ -38,14 +38,14 @@ public ConnectionConfiguration(IConnectionPool connectionPool, IConnection conne
 			: this(connectionPool, connection, null)
 		{ }
 
-		public ConnectionConfiguration(IConnectionPool connectionPool, IElasticsearchSerializer serializer)
-			: this(connectionPool, null, serializer)
+		public ConnectionConfiguration(IConnectionPool connectionPool, Func<ConnectionConfiguration, IElasticsearchSerializer> serializerFactory)
+			: this(connectionPool, null, serializerFactory)
 		{ }
 
 		// 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)
+		public ConnectionConfiguration(IConnectionPool connectionPool, IConnection connection, Func<ConnectionConfiguration, IElasticsearchSerializer> serializerFactory)
+			: base(connectionPool, connection, serializerFactory)
 		{ }
 	}
 
@@ -130,10 +130,11 @@ private static void DefaultApiCallHandler(IApiCallDetails status) { }
 		BasicAuthenticationCredentials _basicAuthCredentials;
 		BasicAuthenticationCredentials IConnectionConfigurationValues.BasicAuthenticationCredentials => _basicAuthCredentials;
 
-		private readonly IElasticsearchSerializer _serializer;
+		protected IElasticsearchSerializer _serializer;
 		IElasticsearchSerializer IConnectionConfigurationValues.Serializer => _serializer;
 
 		private readonly IConnectionPool _connectionPool;
+		private readonly Func<T, IElasticsearchSerializer> _serializerFactory;
 		IConnectionPool IConnectionConfigurationValues.ConnectionPool => _connectionPool;
 
 		private readonly IConnection _connection;
@@ -142,12 +143,13 @@ private static void DefaultApiCallHandler(IApiCallDetails status) { }
 		[System.Diagnostics.CodeAnalysis.SuppressMessage(
 			"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)
+		protected ConnectionConfiguration(IConnectionPool connectionPool, IConnection connection, Func<T, IElasticsearchSerializer> serializerFactory)
 		{
 			this._connectionPool = connectionPool;
 			this._connection = connection ?? new HttpConnection();
+			this._serializerFactory = serializerFactory ?? (c=>this.DefaultSerializer((T)this));
 			// ReSharper disable once VirtualMemberCallInContructor
-			this._serializer = serializer ?? this.DefaultSerializer();
+			this._serializer = this._serializerFactory((T)this);
 
 			this._requestTimeout = ConnectionConfiguration.DefaultTimeout;
 			this._sniffOnConnectionFault = true;
@@ -157,7 +159,7 @@ protected ConnectionConfiguration(IConnectionPool connectionPool, IConnection co
 
 		T Assign(Action<ConnectionConfiguration<T>> assigner) => Fluent.Assign((T)this, assigner);
 
-		protected virtual IElasticsearchSerializer DefaultSerializer() => new ElasticsearchDefaultSerializer();
+		protected virtual IElasticsearchSerializer DefaultSerializer(T settings) => new ElasticsearchDefaultSerializer();
 
 		public T EnableTcpKeepAlive(TimeSpan keepAliveTime, TimeSpan keepAliveInterval) =>
 			Assign(a => { this._keepAliveTime = keepAliveTime; this._keepAliveInterval = keepAliveInterval; });

Diff for: src/Nest/CommonAbstractions/ConnectionSettings/ConnectionSettings.cs

@@ -24,11 +24,11 @@ public ConnectionSettings(IConnectionPool connectionPool)
 		public ConnectionSettings(IConnectionPool connectionPool, IConnection connection)
 			: this(connectionPool, connection, null) { }
 
-		public ConnectionSettings(IConnectionPool connectionPool, IElasticsearchSerializer serializer)
-			: this(connectionPool, null, serializer) { }
+		public ConnectionSettings(IConnectionPool connectionPool, Func<ConnectionSettings, IElasticsearchSerializer> serializerFactory)
+			: this(connectionPool, null, serializerFactory) { }
 
-		public ConnectionSettings(IConnectionPool connectionPool, IConnection connection, IElasticsearchSerializer serializer)
-			: base(connectionPool, connection, serializer) { }
+		public ConnectionSettings(IConnectionPool connectionPool, IConnection connection, Func<ConnectionSettings, IElasticsearchSerializer> serializerFactory)
+			: base(connectionPool, connection, serializerFactory) { }
 	}
 
 	/// <summary>
@@ -57,37 +57,28 @@ public abstract class ConnectionSettings<TConnectionSettings> : ConnectionConfig
 		private Func<string, string> _defaultFieldNameInferrer;
 		Func<string, string> IConnectionSettingsValues.DefaultFieldNameInferrer => _defaultFieldNameInferrer;
 
-		//Serializer settings
-		private Action<JsonSerializerSettings> _modifyJsonSerializerSettings;
-		Action<JsonSerializerSettings> IConnectionSettingsValues.ModifyJsonSerializerSettings => _modifyJsonSerializerSettings;
-
-		private ReadOnlyCollection<Func<Type, JsonConverter>> _contractConverters;
-		ReadOnlyCollection<Func<Type, JsonConverter>> IConnectionSettingsValues.ContractConverters => _contractConverters;
-
 		private readonly FluentDictionary<Type, string> _idProperties = new FluentDictionary<Type, string>();
 		FluentDictionary<Type, string> IConnectionSettingsValues.IdProperties => _idProperties;
 
 		private readonly FluentDictionary<MemberInfo, IPropertyMapping> _propertyMappings = new FluentDictionary<MemberInfo, IPropertyMapping>();
 		FluentDictionary<MemberInfo, IPropertyMapping> IConnectionSettingsValues.PropertyMappings => _propertyMappings;
 
-		protected ConnectionSettings(IConnectionPool connectionPool, IConnection connection, IElasticsearchSerializer serializer)
-			: base(connectionPool, connection, serializer)
+		protected ConnectionSettings(IConnectionPool connectionPool, IConnection connection, Func<TConnectionSettings, IElasticsearchSerializer> serializerFactory)
+			: base(connectionPool, connection, serializerFactory)
 		{
 			this._defaultTypeNameInferrer = (t => t.Name.ToLowerInvariant());
 			this._defaultFieldNameInferrer = (p => p.ToCamelCase());
 			this._defaultIndices = new FluentDictionary<Type, string>();
 			this._defaultTypeNames = new FluentDictionary<Type, string>();
 
-			this._modifyJsonSerializerSettings = j => { };
-			this._contractConverters = Enumerable.Empty<Func<Type, JsonConverter>>().ToList().AsReadOnly();
 			this._inferrer = new ElasticInferrer(this);
 		}
 
 		/// <summary>
 		/// The default serializer for requests and responses
 		/// </summary>
 		/// <returns></returns>
-		protected override IElasticsearchSerializer DefaultSerializer() => new JsonNetSerializer(this);
+		protected override IElasticsearchSerializer DefaultSerializer(TConnectionSettings settings) => new JsonNetSerializer(settings);
 
 		/// <summary>
 		/// This calls SetDefaultTypenameInferrer with an implementation that will pluralize type names. This used to be the default prior to Nest 0.90
@@ -98,26 +89,6 @@ public TConnectionSettings PluralizeTypeNames()
 			return (TConnectionSettings)this;
 		}
 
-		/// <summary>
-		/// Allows you to update internal the json.net serializer settings to your liking
-		/// </summary>
-		public TConnectionSettings JsonSerializerSettingsModifier(Action<JsonSerializerSettings> modifier)
-		{
-			if (modifier == null)
-				return (TConnectionSettings)this;
-			this._modifyJsonSerializerSettings = modifier;
-			return (TConnectionSettings)this;
-
-		}
-		/// <summary>
-		/// Add a custom JsonConverter to the build in json serialization by passing in a predicate for a type.
-		/// </summary>
-		public TConnectionSettings AddContractJsonConverters(params Func<Type, JsonConverter>[] contractSelectors)
-		{
-			this._contractConverters = contractSelectors.ToList().AsReadOnly();
-			return (TConnectionSettings)this;
-		}
-
 		/// <summary>
 		/// The default index to use when no index is specified.
 		/// </summary>

Diff for: src/Nest/CommonAbstractions/ConnectionSettings/IConnectionSettingsValues.cs

@@ -16,7 +16,5 @@ public interface IConnectionSettingsValues : IConnectionConfigurationValues
 		string DefaultIndex { get; }
 		Func<string, string> DefaultFieldNameInferrer { get; }
 		Func<Type, string> DefaultTypeNameInferrer { get; }
-		Action<JsonSerializerSettings> ModifyJsonSerializerSettings { get; }
-		ReadOnlyCollection<Func<Type, JsonConverter>> ContractConverters { get; }
 	}
 }

Diff for: src/Nest/CommonAbstractions/Extensions/TypeExtensions.cs

@@ -23,7 +23,7 @@ internal static class TypeExtensions
 
 		//this contract is only used to resolve properties in class WE OWN.
 		//these are not subject to change depending on what the user passes as connectionsettings
-		private static ElasticContractResolver _jsonContract = new ElasticContractResolver(new ConnectionSettings());
+		private static ElasticContractResolver _jsonContract = new ElasticContractResolver(new ConnectionSettings(), null);
 
 		public delegate T ObjectActivator<out T>(params object[] args);
 

Diff for: src/Nest/CommonAbstractions/SerializationBehavior/ElasticContractResolver.cs

@@ -12,6 +12,7 @@ namespace Nest
 {
 	public class ElasticContractResolver : DefaultContractResolver
 	{
+		private readonly IList<Func<Type, JsonConverter>> _contractConverters;
 		public static JsonSerializer Empty { get; } = new JsonSerializer();
 
 
@@ -25,8 +26,9 @@ public class ElasticContractResolver : DefaultContractResolver
 		/// </summary>
 		internal JsonConverterPiggyBackState PiggyBackState { get; set; }
 
-		public ElasticContractResolver(IConnectionSettingsValues connectionSettings)
+		public ElasticContractResolver(IConnectionSettingsValues connectionSettings, IList<Func<Type, JsonConverter>> contractConverters)
 		{
+			this._contractConverters = contractConverters;
 			this.ConnectionSettings = connectionSettings;
 		}
 
@@ -39,18 +41,18 @@ protected override JsonContract CreateContract(Type objectType)
 
 			if (typeof(IDictionary).IsAssignableFrom(objectType) && !typeof(IIsADictionary).IsAssignableFrom(objectType))
 				contract.Converter = new VerbatimDictionaryKeysJsonConverter();
-			else if (objectType == typeof(ServerError))
-				contract.Converter = new ServerErrorJsonConverter();
+			else if (objectType == typeof(ServerError))
+				contract.Converter = new ServerErrorJsonConverter();
 			else if (objectType == typeof(DateTime) || objectType == typeof(DateTime?))
 				contract.Converter = new IsoDateTimeConverter();
 			else if (!objectType.FullName.StartsWith("Nest.", StringComparison.OrdinalIgnoreCase)) return contract;
 
 			else if (ApplyExactContractJsonAttribute(objectType, contract)) return contract;
 			else if (ApplyContractJsonAttribute(objectType, contract)) return contract;
 
-			if (this.ConnectionSettings.ContractConverters.HasAny())
+			if (this._contractConverters.HasAny())
 			{
-				foreach (var c in this.ConnectionSettings.ContractConverters)
+				foreach (var c in this._contractConverters)
 				{
 					var converter = c(objectType);
 					if (converter == null)

Diff for: src/Nest/CommonAbstractions/SerializationBehavior/JsonNetSerializer.cs

@@ -17,20 +17,28 @@ public class JsonNetSerializer : IElasticsearchSerializer
 		private readonly IConnectionSettingsValues _settings;
 		private readonly Dictionary<SerializationFormatting, JsonSerializer> _defaultSerializers;
 		private readonly JsonSerializer _defaultSerializer;
+		internal JsonSerializer Serializer => _defaultSerializer;
+		private ElasticContractResolver _contractResolver;
+
+		protected virtual void ModifyJsonSerializerSettings(JsonSerializerSettings settings) { }
+		protected virtual IList<Func<Type, JsonConverter>> ContractConverters => null;
 
 		public JsonNetSerializer(IConnectionSettingsValues settings) : this(settings, null) { }
 
 		/// <summary>
 		/// this constructor is only here for stateful (de)serialization 
 		/// </summary>
-		public JsonNetSerializer(IConnectionSettingsValues settings, JsonConverter stateFullConverter)
+		internal JsonNetSerializer(IConnectionSettingsValues settings, JsonConverter stateFullConverter)
 		{
 			this._settings = settings;
+			var piggyBackState = stateFullConverter == null ? null : new JsonConverterPiggyBackState { ActualJsonConverter = stateFullConverter };
+			// ReSharper disable once VirtualMemberCallInContructor
+			this._contractResolver = new ElasticContractResolver(this._settings, this.ContractConverters) { PiggyBackState = piggyBackState };
 
-			this._defaultSerializer = JsonSerializer.Create(this.CreateSettings(SerializationFormatting.None, stateFullConverter));
-			this._defaultSerializer.Formatting = Formatting.None; 
-			var indentedSerializer = JsonSerializer.Create(this.CreateSettings(SerializationFormatting.Indented, stateFullConverter));
-			indentedSerializer.Formatting = Formatting.Indented; 
+			this._defaultSerializer = JsonSerializer.Create(this.CreateSettings(SerializationFormatting.None));
+			//this._defaultSerializer.Formatting = Formatting.None; 
+			var indentedSerializer = JsonSerializer.Create(this.CreateSettings(SerializationFormatting.Indented));
+			//indentedSerializer.Formatting = Formatting.Indented; 
 			this._defaultSerializers = new Dictionary<SerializationFormatting, JsonSerializer>
 			{
 				{ SerializationFormatting.None, this._defaultSerializer },
@@ -51,7 +59,7 @@ public void Serialize(object data, Stream writableStream, SerializationFormattin
 		}
 
 		public string CreatePropertyName(MemberInfo memberInfo)
-		{
+		{
 			var jsonProperty = memberInfo.GetCustomAttribute<JsonPropertyAttribute>(true);
 			return jsonProperty?.PropertyName;
 		}
@@ -74,22 +82,20 @@ public virtual T Deserialize<T>(Stream stream)
 			return Task.FromResult<T>(result);
 		}
 
-		internal JsonSerializerSettings CreateSettings(SerializationFormatting formatting, JsonConverter piggyBackJsonConverter = null)
+		private JsonSerializerSettings CreateSettings(SerializationFormatting formatting)
 		{
-			var piggyBackState = new JsonConverterPiggyBackState { ActualJsonConverter = piggyBackJsonConverter };
 			var settings = new JsonSerializerSettings()
 			{
 				Formatting = formatting == SerializationFormatting.Indented ? Formatting.Indented : Formatting.None,
-				ContractResolver = new ElasticContractResolver(this._settings),
+				ContractResolver = this._contractResolver,
 				DefaultValueHandling = DefaultValueHandling.Include,
 				NullValueHandling = NullValueHandling.Ignore
 			};
 
-			_settings.ModifyJsonSerializerSettings?.Invoke(settings);
+			this.ModifyJsonSerializerSettings(settings);
 
 			var contract = settings.ContractResolver as ElasticContractResolver;
 			if (contract == null) throw new Exception($"NEST needs an instance of {nameof(ElasticContractResolver)} registered on Json.NET's JsonSerializerSettings");
-			contract.PiggyBackState = piggyBackState;
 
 			return settings;
 		}

Diff for: src/Nest/Search/MultiSearch/MultiSearchResponseJsonConverter.cs

@@ -59,21 +59,12 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 
 				if (concreteTypeSelector != null)
 				{
-					var elasticSerializer = new JsonNetSerializer(this._settings);
 					var state = typeof(ConcreteTypeConverter<>).CreateGenericInstance(baseType, concreteTypeSelector) as JsonConverter;
 					if (state != null)
 					{
-						var settings = elasticSerializer.CreateSettings(SerializationFormatting.None, piggyBackJsonConverter: state);
-
-						var jsonSerializer = new JsonSerializer()
-						{
-							NullValueHandling = settings.NullValueHandling,
-							DefaultValueHandling = settings.DefaultValueHandling,
-							ContractResolver = settings.ContractResolver,
-						};
-						foreach (var converter in settings.Converters.EmptyIfNull())
-							jsonSerializer.Converters.Add(converter);
-						generic.Invoke(null, new object[] { m, jsonSerializer, response.Responses, this._settings });
+						var elasticSerializer = new JsonNetSerializer(this._settings, state);
+
+						generic.Invoke(null, new object[] { m, elasticSerializer.Serializer, response.Responses, this._settings });
 						continue;
 					}
 				}
@@ -104,10 +95,10 @@ IConnectionSettingsValues settings
 		{
 			var response = new SearchResponse<T>();
 			var reader = tuple.Hit.CreateReader();
-			serializer.Populate(reader, response);
-
+			serializer.Populate(reader, response);
+
 			ServerError error;
-			if (tuple.Hit.TryParseServerError(serializer, out error))
+			if (tuple.Hit.TryParseServerError(serializer, out error))
 				response.MultiSearchError = error ;
 
 			collection.Add(tuple.Descriptor.Key, response);

Diff for: src/Tests/ClientConcepts/LowLevel/Connecting.doc.cs

@@ -1,8 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Net;
 using Elasticsearch.Net;
+using FluentAssertions;
 using Nest;
+using Newtonsoft.Json;
+using Tests.Framework;
 
 namespace Tests.ClientConcepts.LowLevel
 {
@@ -192,5 +196,27 @@ public void ConfiguringSSL()
 			 * therefore we recommend doing some minimal introspection on the passed in certificate.
 			 */
 		}
+
+		public class MyJsonNetSerializer : JsonNetSerializer
+		{
+			public int X { get; set; } = 0;
+			public MyJsonNetSerializer(IConnectionSettingsValues settings) : base(settings) { }
+
+			protected override void ModifyJsonSerializerSettings(JsonSerializerSettings settings)
+			{
+				++X;
+			}
+		}
+
+		[U] public void IsCalled()
+		{
+			var connectionPool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
+			var settings = new ConnectionSettings(connectionPool, new InMemoryConnection(),s => new MyJsonNetSerializer(s));
+			var client = new ElasticClient(settings);
+			client.RootNodeInfo();
+			client.RootNodeInfo();
+			var serializer = ((IConnectionSettingsValues)settings).Serializer as MyJsonNetSerializer;
+			serializer.X.Should().BeGreaterThan(0);
+		}
 	}
 }