Add is_write_index to aliases on create index API (#3704)

This commit adds the ability to add an alias with is_write_index when creating an index using the Create Index API.

Closes #3686

Author: russcam

src/Nest/Indices/AliasManagement/Alias.cs

@@ -3,44 +3,83 @@
 
 namespace Nest
 {
+	/// <summary>
+	/// An alias to one or more indices
+	/// </summary>
 	[ReadAs(typeof(Alias))]
 	public interface IAlias
 	{
-		[DataMember(Name ="filter")]
+		/// <summary>
+		/// Provides an easy way to create different "views" of the same index. A filter can be defined using Query DSL and is
+		/// applied to all Search, Count, Delete By Query and More Like This operations with this alias.
+		/// </summary>
+		[DataMember(Name = "filter")]
 		QueryContainer Filter { get; set; }
 
-		[DataMember(Name ="index_routing")]
+		/// <summary>
+		/// Associates routing values with aliases for index operations. This feature can be used together
+		/// with filtering aliases in order to avoid unnecessary shard operations.
+		/// </summary>
+		[DataMember(Name = "index_routing")]
 		Routing IndexRouting { get; set; }
 
-		[DataMember(Name ="routing")]
+		/// <inheritdoc cref="AliasAddOperation.IsWriteIndex" />
+		[DataMember(Name = "is_write_index")]
+		bool? IsWriteIndex { get; set; }
+
+		/// <summary>
+		/// Associates routing values with aliases for both index and search operations. This feature can be used together
+		/// with filtering aliases in order to avoid unnecessary shard operations.
+		/// </summary>
+		[DataMember(Name = "routing")]
 		Routing Routing { get; set; }
 
-		[DataMember(Name ="search_routing")]
+		/// <summary>
+		/// Associates routing values with aliases for search operations. This feature can be used together
+		/// with filtering aliases in order to avoid unnecessary shard operations.
+		/// </summary>
+		[DataMember(Name = "search_routing")]
 		Routing SearchRouting { get; set; }
 	}
 
+	/// <inheritdoc />
 	public class Alias : IAlias
 	{
+		/// <inheritdoc />
 		public QueryContainer Filter { get; set; }
+		/// <inheritdoc />
 		public Routing IndexRouting { get; set; }
+		/// <inheritdoc />
+		public bool? IsWriteIndex { get; set; }
+		/// <inheritdoc />
 		public Routing Routing { get; set; }
+		/// <inheritdoc />
 		public Routing SearchRouting { get; set; }
 	}
 
+	/// <inheritdoc cref="IAlias" />
 	public class AliasDescriptor : DescriptorBase<AliasDescriptor, IAlias>, IAlias
 	{
 		QueryContainer IAlias.Filter { get; set; }
 		Routing IAlias.IndexRouting { get; set; }
+		bool? IAlias.IsWriteIndex { get; set; }
 		Routing IAlias.Routing { get; set; }
 		Routing IAlias.SearchRouting { get; set; }
 
-		public AliasDescriptor Routing(Routing routing) => Assign(routing, (a, v) => a.Routing = v);
+		/// <inheritdoc cref="IAlias.Filter" />
+		public AliasDescriptor Filter<T>(Func<QueryContainerDescriptor<T>, QueryContainer> filterSelector) where T : class =>
+			Assign(filterSelector, (a, v) => a.Filter = v?.Invoke(new QueryContainerDescriptor<T>()));
 
+		/// <inheritdoc cref="IAlias.IndexRouting" />
 		public AliasDescriptor IndexRouting(Routing indexRouting) => Assign(indexRouting, (a, v) => a.IndexRouting = v);
 
-		public AliasDescriptor SearchRouting(Routing searchRouting) => Assign(searchRouting, (a, v) => a.SearchRouting = v);
+		/// <inheritdoc cref="IAlias.IsWriteIndex" />
+		public AliasDescriptor IsWriteIndex(bool? isWriteIndex = true) => Assign(isWriteIndex, (a, v) => a.IsWriteIndex = v);
 
-		public AliasDescriptor Filter<T>(Func<QueryContainerDescriptor<T>, QueryContainer> filterSelector) where T : class =>
-			Assign(filterSelector, (a, v) => a.Filter = v?.Invoke(new QueryContainerDescriptor<T>()));
+		/// <inheritdoc cref="IAlias.Routing" />
+		public AliasDescriptor Routing(Routing routing) => Assign(routing, (a, v) => a.Routing = v);
+
+		/// <inheritdoc cref="IAlias.SearchRouting" />
+		public AliasDescriptor SearchRouting(Routing searchRouting) => Assign(searchRouting, (a, v) => a.SearchRouting = v);
 	}
 }

src/Nest/Indices/AliasManagement/PutAlias/PutAliasRequest.cs

@@ -3,35 +3,45 @@
 
 namespace Nest
 {
+	/// <summary>
+	/// A request to put an alias to one or more indices
+	/// </summary>
 	[MapsApi("indices.put_alias.json")]
 	public partial interface IPutAliasRequest
 	{
-		[DataMember(Name ="filter")]
+		/// <inheritdoc cref="IAlias.Filter"/>
+		[DataMember(Name = "filter")]
 		QueryContainer Filter { get; set; }
 
-		[DataMember(Name ="index_routing")]
+		/// <inheritdoc cref="IAlias.IndexRouting"/>
+		[DataMember(Name = "index_routing")]
 		Routing IndexRouting { get; set; }
 
-		/// <inheritdoc cref="AliasAddOperation.IsWriteIndex" />
-		[DataMember(Name ="is_write_index")]
+		/// <inheritdoc cref="IAlias.IsWriteIndex" />
+		[DataMember(Name = "is_write_index")]
 		bool? IsWriteIndex { get; set; }
 
-		[DataMember(Name ="routing")]
+		/// <inheritdoc cref="IAlias.Routing"/>
+		[DataMember(Name = "routing")]
 		Routing Routing { get; set; }
 
-		[DataMember(Name ="search_routing")]
+		/// <inheritdoc cref="IAlias.SearchRouting"/>
+		[DataMember(Name = "search_routing")]
 		Routing SearchRouting { get; set; }
 	}
 
+	/// <inheritdoc cref="IPutAliasRequest"/>
 	public partial class PutAliasRequest
 	{
+		/// <inheritdoc cref="IPutAliasRequest.Filter"/>
 		public QueryContainer Filter { get; set; }
+		/// <inheritdoc cref="IPutAliasRequest.IndexRouting"/>
 		public Routing IndexRouting { get; set; }
-
-		/// <inheritdoc cref="AliasAddOperation.IsWriteIndex" />
+		/// <inheritdoc cref="IPutAliasRequest.IsWriteIndex" />
 		public bool? IsWriteIndex { get; set; }
-
+		/// <inheritdoc cref="IPutAliasRequest.Routing"/>
 		public Routing Routing { get; set; }
+		/// <inheritdoc cref="IPutAliasRequest.SearchRouting"/>
 		public Routing SearchRouting { get; set; }
 	}
 
@@ -43,15 +53,19 @@ public partial class PutAliasDescriptor
 		Routing IPutAliasRequest.Routing { get; set; }
 		Routing IPutAliasRequest.SearchRouting { get; set; }
 
+		/// <inheritdoc cref="IPutAliasRequest.Routing"/>
 		public PutAliasDescriptor Routing(Routing routing) => Assign(routing, (a, v) => a.Routing = v);
 
+		/// <inheritdoc cref="IPutAliasRequest.IndexRouting"/>
 		public PutAliasDescriptor IndexRouting(Routing routing) => Assign(routing, (a, v) => a.IndexRouting = v);
 
+		/// <inheritdoc cref="IPutAliasRequest.SearchRouting"/>
 		public PutAliasDescriptor SearchRouting(Routing routing) => Assign(routing, (a, v) => a.SearchRouting = v);
 
-		/// <inheritdoc cref="AliasAddOperation.IsWriteIndex" />
+		/// <inheritdoc cref="IPutAliasRequest.IsWriteIndex" />
 		public PutAliasDescriptor IsWriteIndex(bool? isWriteIndex = true) => Assign(isWriteIndex, (a, v) => a.IsWriteIndex = v);
 
+		/// <inheritdoc cref="IPutAliasRequest.Filter"/>
 		public PutAliasDescriptor Filter<T>(Func<QueryContainerDescriptor<T>, QueryContainer> filterSelector) where T : class =>
 			Assign(filterSelector, (a, v) => a.Filter = v?.Invoke(new QueryContainerDescriptor<T>()));
 	}

src/Tests/Tests/Indices/IndexManagement/CreateIndex/CreateIndexApiTests.cs

@@ -240,4 +240,80 @@ protected override void ExpectResponse(CreateIndexResponse response)
 			((InlineScript)scriptedSimilarity.Script).Source.Should().NotBeNullOrEmpty();
 		}
 	}
+
+	public class CreateIndexWithAliasApiTests
+		: ApiIntegrationTestBase<WritableCluster, CreateIndexResponse, ICreateIndexRequest, CreateIndexDescriptor, CreateIndexRequest>
+	{
+		public CreateIndexWithAliasApiTests(WritableCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		protected override bool ExpectIsValid => true;
+
+		protected override object ExpectJson => new
+		{
+			settings = new Dictionary<string, object>
+			{
+				{ "index.number_of_replicas", 0 },
+				{ "index.number_of_shards", 1 },
+			},
+			aliases = new Dictionary<string, object>
+			{
+				{ CallIsolatedValue + "-alias", new { is_write_index = true } }
+			}
+		};
+
+		protected override int ExpectStatusCode => 200;
+
+		protected override Func<CreateIndexDescriptor, ICreateIndexRequest> Fluent => d => d
+			.Settings(s => s
+				.NumberOfReplicas(0)
+				.NumberOfShards(1)
+			)
+			.Aliases(a => a
+				.Alias(CallIsolatedValue + "-alias", aa => aa
+					.IsWriteIndex()
+				)
+			);
+
+		protected override HttpMethod HttpMethod => HttpMethod.PUT;
+
+		protected override CreateIndexRequest Initializer => new CreateIndexRequest(CallIsolatedValue)
+		{
+			Settings = new Nest.IndexSettings
+			{
+				NumberOfReplicas = 0,
+				NumberOfShards = 1,
+			},
+			Aliases = new Aliases
+			{
+				{ CallIsolatedValue + "-alias", new Alias { IsWriteIndex = true } }
+			}
+		};
+
+		protected override string UrlPath => $"/{CallIsolatedValue}";
+
+		protected override LazyResponses ClientUsage() => Calls(
+			(client, f) => client.CreateIndex(CallIsolatedValue, f),
+			(client, f) => client.CreateIndexAsync(CallIsolatedValue, f),
+			(client, r) => client.CreateIndex(r),
+			(client, r) => client.CreateIndexAsync(r)
+		);
+
+		protected override CreateIndexDescriptor NewDescriptor() => new CreateIndexDescriptor(CallIsolatedValue);
+
+		protected override void ExpectResponse(CreateIndexResponse response)
+		{
+			response.ShouldBeValid();
+			response.Acknowledged.Should().BeTrue();
+			response.ShardsAcknowledged.Should().BeTrue();
+
+			var indexResponse = Client.GetIndex(CallIsolatedValue);
+
+			indexResponse.ShouldBeValid();
+			indexResponse.Indices.Should().NotBeEmpty().And.ContainKey(CallIsolatedValue);
+
+			var aliases = indexResponse.Indices[CallIsolatedValue].Aliases;
+			aliases.Count.Should().Be(1);
+			aliases[CallIsolatedValue + "-alias"].IsWriteIndex.Should().BeTrue();
+		}
+	}
 }