Add support for ip_range datatype

src/Nest/Aggregations/Bucket/IpRange/IpRangeAggregation.cs

@@ -14,13 +14,13 @@ public interface IIpRangeAggregation : IBucketAggregation
 		Field Field { get; set; }
 
 		[JsonProperty("ranges")]
-		IEnumerable<IIpRange> Ranges { get; set; }
+		IEnumerable<IIpRangeAggregationRange> Ranges { get; set; }
 	}
 
 	public class IpRangeAggregation : BucketAggregationBase, IIpRangeAggregation
 	{
 		public Field Field { get; set; }
-		public IEnumerable<IIpRange> Ranges { get; set; }
+		public IEnumerable<IIpRangeAggregationRange> Ranges { get; set; }
 
 		internal IpRangeAggregation() { }
 
@@ -36,13 +36,13 @@ public class IpRangeAggregationDescriptor<T> :
 	{
 		Field IIpRangeAggregation.Field { get; set; }
 
-		IEnumerable<IIpRange> IIpRangeAggregation.Ranges { get; set; }
+		IEnumerable<IIpRangeAggregationRange> IIpRangeAggregation.Ranges { get; set; }
 
 		public IpRangeAggregationDescriptor<T> Field(Field field) => Assign(a => a.Field = field);
 
 		public IpRangeAggregationDescriptor<T> Field(Expression<Func<T, object>> field) => Assign(a => a.Field = field);
 
-		public IpRangeAggregationDescriptor<T> Ranges(params Func<IpRangeDescriptor, IIpRange>[] ranges) =>
-			Assign(a => a.Ranges = ranges?.Select(r => r(new IpRangeDescriptor())));
+		public IpRangeAggregationDescriptor<T> Ranges(params Func<IpRangeAggregationRangeDescriptor, IIpRangeAggregationRange>[] ranges) =>
+			Assign(a => a.Ranges = ranges?.Select(r => r(new IpRangeAggregationRangeDescriptor())));
 	}
 }

src/Nest/Aggregations/Bucket/IpRange/IpRangeAggregationRange.cs

@@ -0,0 +1,39 @@
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<IpRangeAggregationRange>))]
+	public interface IIpRangeAggregationRange
+	{
+		[JsonProperty("from")]
+		string From { get; set; }
+
+		[JsonProperty("to")]
+		string To { get; set; }
+
+		[JsonProperty("mask")]
+		string Mask { get; set; }
+	}
+
+	public class IpRangeAggregationRange : IIpRangeAggregationRange
+	{
+		public string From { get; set; }
+
+		public string To { get; set; }
+
+		public string Mask { get; set; }
+	}
+
+	public class IpRangeAggregationRangeDescriptor
+		: DescriptorBase<IpRangeAggregationRangeDescriptor, IIpRangeAggregationRange>, IIpRangeAggregationRange
+	{
+		string IIpRangeAggregationRange.From { get; set; }
+		string IIpRangeAggregationRange.Mask { get; set; }
+		string IIpRangeAggregationRange.To { get; set; }
+
+		public IpRangeAggregationRangeDescriptor From(string from) => Assign(a => a.From = from);
+		public IpRangeAggregationRangeDescriptor To(string to) => Assign(a => a.To = to);
+		public IpRangeAggregationRangeDescriptor Mask(string mask) => Assign(a => a.Mask = mask);
+	}
+}

src/Nest/CommonOptions/Range/Ranges.cs

@@ -73,4 +73,18 @@ public class LongRange
 		[JsonProperty("lt")]
 		public long? LessThan { get; set; }
 	}
+	public class IpRange
+	{
+		[JsonProperty("gte")]
+		public string GreaterThanOrEqualTo { get; set; }
+
+		[JsonProperty("lte")]
+		public string LessThanOrEqualTo { get; set; }
+
+		[JsonProperty("gt")]
+		public string GreaterThan { get; set; }
+
+		[JsonProperty("lt")]
+		public string LessThan { get; set; }
+	}
 }

src/Nest/Mapping/DynamicTemplate/SingleMapping.cs

@@ -73,6 +73,9 @@ public IProperty IntegerRange(Func<IntegerRangePropertyDescriptor<T>, IIntegerRa
 		public IProperty LongRange(Func<LongRangePropertyDescriptor<T>, ILongRangeProperty> selector) =>
 			selector?.Invoke(new LongRangePropertyDescriptor<T>());
 
+		public IProperty IpRange(Func<IpRangePropertyDescriptor<T>, IIpRangeProperty> selector) =>
+			selector?.Invoke(new IpRangePropertyDescriptor<T>());
+
 		public IProperty Join(Func<JoinPropertyDescriptor<T>, IJoinProperty> selector) =>
 			selector?.Invoke(new JoinPropertyDescriptor<T>());
 
@@ -239,6 +242,8 @@ public IProperty Scalar(Expression<Func<T, IntegerRange>> field, Func<IntegerRan
 			selector.InvokeOrDefault(new IntegerRangePropertyDescriptor<T>().Name(field));
 		public IProperty Scalar(Expression<Func<T, FloatRange>> field, Func<FloatRangePropertyDescriptor<T>, IFloatRangeProperty> selector = null) =>
 			selector.InvokeOrDefault(new FloatRangePropertyDescriptor<T>().Name(field));
+		public IProperty Scalar(Expression<Func<T, IpRange>> field, Func<IpRangePropertyDescriptor<T>, IIpRangeProperty> selector = null) =>
+			selector.InvokeOrDefault(new IpRangePropertyDescriptor<T>().Name(field));
 #pragma warning restore CS3001 // Argument type is not CLS-compliant
 	}
 }

src/Nest/Mapping/Types/Core/Range/Ip/IpRangeAttribute.cs

@@ -0,0 +1,10 @@
+using System;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public class IpRangeAttribute : RangePropertyAttributeBase, IIpRangeProperty
+	{
+		public IpRangeAttribute() : base(RangeType.IpRange) { }
+	}
+}

src/Nest/Mapping/Types/Core/Range/Ip/IpRangeProperty.cs

@@ -0,0 +1,21 @@
+using System;
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization.OptIn)]
+	public interface IIpRangeProperty : IRangeProperty { }
+
+	public class IpRangeProperty : RangePropertyBase, IIpRangeProperty
+	{
+		public IpRangeProperty() : base(RangeType.IpRange) { }
+	}
+
+	public class IpRangePropertyDescriptor<T>
+		: RangePropertyDescriptorBase<IpRangePropertyDescriptor<T>, IIpRangeProperty, T>, IIpRangeProperty
+		where T : class
+	{
+		public IpRangePropertyDescriptor() : base(RangeType.IpRange) { }
+	}
+}

src/Nest/Mapping/Types/Core/Range/RangePropertyBase.cs

@@ -49,11 +49,11 @@ public abstract class RangePropertyDescriptorBase<TDescriptor, TInterface, T>
 
 		protected RangePropertyDescriptorBase(RangeType type) : base(type.ToFieldType()) { }
 
-		/// <inheritdoc/>
+		/// <inheritdoc cref="IRangeProperty.Coerce"/>
 		public TDescriptor Coerce(bool? coerce = true) => Assign(a => a.Coerce = coerce);
-		/// <inheritdoc/>
+		/// <inheritdoc cref="IRangeProperty.Boost"/>
 		public TDescriptor Boost(double? boost) => Assign(a => a.Boost = boost);
-		/// <inheritdoc/>
+		/// <inheritdoc cref="IRangeProperty.Index"/>
 		public TDescriptor Index(bool? index = true) => Assign(a => a.Index = index);
 	}
 }

src/Nest/Mapping/Types/Core/Range/RangeType.cs

@@ -32,7 +32,12 @@ public enum RangeType
 		/// A range of date values represented as unsigned 64-bit integer milliseconds elapsed since system epoch.
 		/// </summary>
 		[EnumMember(Value = "date_range")]
-		DateRange
+		DateRange,
+		/// <summary>
+		/// A range of ip values supporting either IPv4 or IPv6 (or mixed) addresses.
+		/// </summary>
+		[EnumMember(Value = "ip_range")]
+		IpRange
 	}
 	internal static class RangeTypeExtensions
 	{
@@ -45,6 +50,7 @@ public static FieldType ToFieldType(this RangeType rangeType)
 				case RangeType.LongRange: return FieldType.LongRange;
 				case RangeType.DoubleRange: return FieldType.DoubleRange;
 				case RangeType.DateRange: return FieldType.DateRange;
+				case RangeType.IpRange: return FieldType.IpRange;
 				default:
 					throw new ArgumentOutOfRangeException(nameof(rangeType), rangeType, null);
 			}

src/Nest/Mapping/Types/FieldType.cs

@@ -84,6 +84,8 @@ public enum FieldType
 		DoubleRange,
 		[EnumMember(Value = "date_range")]
 		DateRange,
+		[EnumMember(Value = "ip_range")]
+		IpRange,
 		[EnumMember(Value = "join")]
 		Join,
 	}

src/Nest/Mapping/Types/Properties-Scalar.cs

@@ -100,6 +100,7 @@ public partial interface IPropertiesDescriptor<T, out TReturnType>
 		TReturnType Scalar(Expression<Func<T, LongRange>> field, Func<LongRangePropertyDescriptor<T>, ILongRangeProperty> selector = null);
 		TReturnType Scalar(Expression<Func<T, IntegerRange>> field, Func<IntegerRangePropertyDescriptor<T>, IIntegerRangeProperty> selector = null);
 		TReturnType Scalar(Expression<Func<T, FloatRange>> field, Func<FloatRangePropertyDescriptor<T>, IFloatRangeProperty> selector = null);
+		TReturnType Scalar(Expression<Func<T, IpRange>> field, Func<IpRangePropertyDescriptor<T>, IIpRangeProperty> selector = null);
 #pragma warning restore CS3001 // Argument type is not CLS-compliant
 	}
 
@@ -269,6 +270,8 @@ public PropertiesDescriptor<T> Scalar(Expression<Func<T, IntegerRange>> field, F
 			SetProperty(selector.InvokeOrDefault(new IntegerRangePropertyDescriptor<T>().Name(field)));
 		public PropertiesDescriptor<T> Scalar(Expression<Func<T, FloatRange>> field, Func<FloatRangePropertyDescriptor<T>, IFloatRangeProperty> selector = null) =>
 			SetProperty(selector.InvokeOrDefault(new FloatRangePropertyDescriptor<T>().Name(field)));
+		public PropertiesDescriptor<T> Scalar(Expression<Func<T, IpRange>> field, Func<IpRangePropertyDescriptor<T>, IIpRangeProperty> selector = null) =>
+			SetProperty(selector.InvokeOrDefault(new IpRangePropertyDescriptor<T>().Name(field)));
 
 #pragma warning restore CS3001 // Argument type is not CLS-compliant
 	}

src/Nest/Mapping/Types/Properties.cs

@@ -72,6 +72,7 @@ TReturnType Nested<TChild>(Func<NestedPropertyDescriptor<T, TChild>, INestedProp
 		TReturnType FloatRange(Func<FloatRangePropertyDescriptor<T>, IFloatRangeProperty> selector);
 		TReturnType IntegerRange(Func<IntegerRangePropertyDescriptor<T>, IIntegerRangeProperty> selector);
 		TReturnType LongRange(Func<LongRangePropertyDescriptor<T>, ILongRangeProperty> selector);
+		TReturnType IpRange(Func<IpRangePropertyDescriptor<T>, IIpRangeProperty> selector);
 		TReturnType Join(Func<JoinPropertyDescriptor<T>, IJoinProperty> selector);
 	}
 
@@ -127,6 +128,8 @@ public PropertiesDescriptor<T> Nested<TChild>(Func<NestedPropertyDescriptor<T, T
 
 		public PropertiesDescriptor<T> LongRange(Func<LongRangePropertyDescriptor<T>, ILongRangeProperty> selector) => SetProperty(selector);
 
+		public PropertiesDescriptor<T> IpRange(Func<IpRangePropertyDescriptor<T>, IIpRangeProperty> selector) => SetProperty(selector);
+
 		public PropertiesDescriptor<T> Join(Func<JoinPropertyDescriptor<T>, IJoinProperty> selector) => SetProperty(selector);
 
 		public PropertiesDescriptor<T> Custom(IProperty customType) => SetProperty(customType);

src/Nest/Mapping/Types/PropertiesJsonConverter.cs

@@ -54,14 +54,10 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 			foreach (var p in o.Properties())
 			{
 				var name = p.Name;
-				var po = p.First as JObject;
-				if (po == null) continue;
-
-				var mapping = _elasticTypeConverter.ReadJson(po.CreateReader(), objectType, existingValue, serializer) as IProperty;
-				if (mapping == null) continue;
+				if (!(p.First is JObject po)) continue;
+				if (!(_elasticTypeConverter.ReadJson(po.CreateReader(), objectType, existingValue, serializer) is IProperty mapping)) continue;
 
 				mapping.Name = name;
-
 				r.Add(name, mapping);
 			}
 			return r;

src/Nest/Mapping/Types/PropertyJsonConverter.cs

@@ -11,16 +11,11 @@ internal class PropertyJsonConverter : JsonConverter
 
 		public override bool CanConvert(Type objectType) => objectType == typeof(IProperty);
 
-		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-		{
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) =>
 			throw new NotSupportedException();
-		}
 
-		private TProperty ReadProperty<TProperty>(JObject j, JsonSerializer s)
-			where TProperty : IProperty
-		{
-			return FromJson.ReadAs<TProperty>(j.CreateReader(), s);
-		}
+		private TProperty ReadProperty<TProperty>(JObject j, JsonSerializer s) where TProperty : IProperty =>
+			FromJson.ReadAs<TProperty>(j.CreateReader(), s);
 
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
@@ -64,6 +59,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 				case FieldType.FloatRange: return ReadProperty<FloatRangeProperty>(jObject, serializer);
 				case FieldType.IntegerRange: return ReadProperty<IntegerRangeProperty>(jObject, serializer);
 				case FieldType.LongRange: return ReadProperty<LongRangeProperty>(jObject, serializer);
+				case FieldType.IpRange: return ReadProperty<IpRangeProperty>(jObject, serializer);
 				case FieldType.Join: return ReadProperty<JoinProperty>(jObject, serializer);
 				case FieldType.None:
 					break;

src/Nest/Mapping/Visitor/PropertyWalker.cs

@@ -155,6 +155,9 @@ private static IProperty InferProperty(PropertyInfo propertyInfo)
 			if (type == typeof(LongRange))
 				return new LongRangeProperty();
 
+			if (type == typeof(IpRange))
+				return new IpRangeProperty();
+
 			return new ObjectProperty();
 		}
 

src/Tests/Aggregations/Bucket/IpRange/IpRangeAggregationUsageTests.cs

@@ -44,10 +44,10 @@ public IpRangeAggregationUsageTests(ReadOnlyCluster i, EndpointUsage usage) : ba
 			new IpRangeAggregation("ip_ranges")
 			{
 				Field = Field((Project p) => p.LeadDeveloper.IpAddress),
-				Ranges = new List<Nest.IpRange>
+				Ranges = new List<Nest.IpRangeAggregationRange>
 				{
-					new Nest.IpRange {To = "127.0.0.1"},
-					new Nest.IpRange {From = "127.0.0.1"}
+					new Nest.IpRangeAggregationRange {To = "127.0.0.1"},
+					new Nest.IpRangeAggregationRange {From = "127.0.0.1"}
 				}
 			};
 

src/Tests/Framework/MockData/Ranges.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Net;
 using Bogus;
 using Nest;
 
@@ -11,6 +12,7 @@ public class Ranges
 		public FloatRange Floats { get; set; }
 		public IntegerRange Integers { get; set; }
 		public LongRange Longs { get; set; }
+		public IpRange Ips { get; set; }
 
 		//for deserialization
 		public Ranges() { }
@@ -23,6 +25,7 @@ private Ranges(Faker faker)
 			SetFloats(faker, r);
 			SetIntegers(faker, r);
 			SetLongs(faker, r);
+			SetIps(faker, r);
 		}
 
 		private void SetDates(Faker faker, Func<bool> r)
@@ -70,6 +73,27 @@ private void SetLongs(Faker faker, Func<bool> r)
 			SwapAssign(r(), high, v => d.LessThan = v, v => d.LessThanOrEqualTo = v);
 			this.Longs = d;
 		}
+		private void SetIps(Faker faker, Func<bool> r)
+		{
+			var low = faker.Internet.Ip();
+			var high = faker.Internet.Ip();
+			var lowBytes = IPAddress.Parse(low).GetAddressBytes();
+			var highBytes = IPAddress.Parse(high).GetAddressBytes();
+			for (int i = 0; i < lowBytes.Length; i++)
+			{
+				if (lowBytes[i] > highBytes[i])
+				{
+					var s = low;
+					low = high;
+					high = s;
+					break;
+				}
+			}
+			var d = new IpRange();
+			SwapAssign(r(), low, v => d.GreaterThan = v, v => d.GreaterThanOrEqualTo = v);
+			SwapAssign(r(), high, v => d.LessThan = v, v => d.LessThanOrEqualTo = v);
+			this.Ips = d;
+		}
 
 		private static void SwapAssign<T>(bool b, T value, Action<T> first, Action<T> second)
 		{