add support for write index resolution when creating/updating documents

server/src/main/java/org/elasticsearch/cluster/metadata/IndexNameExpressionResolver.java

@@ -196,13 +196,9 @@ Index[] concreteIndices(Context context, String... indexExpressions) {
                 AliasOrIndex.Alias alias = (AliasOrIndex.Alias) aliasOrIndex;
                 IndexMetaData writeIndex = alias.getWriteIndex();
                 if (writeIndex == null) {
-                    if (alias.getIndices().size() > 1) {
-                        throw new IllegalArgumentException("Alias [" + alias.getAliasName() +
-                            "] points to multiple indices with none set as a write-index [is_write_index=true]");
-                    } else {
-                        throw new IllegalArgumentException("Alias [" + alias.getAliasName() + "] points to an index ["
-                            + alias.getIndices().get(0).getIndex().getName() + "] with [is_write_index=false]");
-                    }
+                    throw new IllegalArgumentException("no write index is defined for alias [" + alias.getAliasName() + "]." +
+                        " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple" +
+                        " indices without one being designated as a write index");
                 }
                 concreteIndices.add(writeIndex.getIndex());
             } else {

server/src/test/java/org/elasticsearch/action/bulk/BulkIntegrationIT.java

@@ -20,13 +20,21 @@
 
 package org.elasticsearch.action.bulk;
 
+import org.elasticsearch.action.admin.indices.alias.Alias;
 import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse;
+import org.elasticsearch.action.get.GetRequestBuilder;
+import org.elasticsearch.action.index.IndexRequest;
+import org.elasticsearch.cluster.metadata.IndexMetaData;
 import org.elasticsearch.common.xcontent.XContentType;
+import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.test.ESIntegTestCase;
 
 import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.Map;
 
 import static org.elasticsearch.test.StreamsUtils.copyToStringFromClasspath;
+import static org.hamcrest.Matchers.equalTo;
 
 public class BulkIntegrationIT extends ESIntegTestCase {
     public void testBulkIndexCreatesMapping() throws Exception {
@@ -40,4 +48,51 @@ public void testBulkIndexCreatesMapping() throws Exception {
             assertTrue(mappingsResponse.getMappings().get("logstash-2014.03.30").containsKey("logs"));
         });
     }
+
+    /**
+     * This tests that the {@link TransportBulkAction} evaluates alias routing values correctly when dealing with
+     * an alias pointing to multiple indices, while a write index exits.
+     */
+    public void testBulkWithWriteIndexAndRouting() {
+        Map<String, Integer> twoShardsSettings = Collections.singletonMap(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 2);
+        client().admin().indices().prepareCreate("index1")
+            .addAlias(new Alias("alias1").indexRouting("0")).setSettings(twoShardsSettings).get();
+        client().admin().indices().prepareCreate("index2")
+            .addAlias(new Alias("alias1").indexRouting("0").writeIndex(randomFrom(false, null)))
+            .setSettings(twoShardsSettings).get();
+        client().admin().indices().prepareCreate("index3")
+            .addAlias(new Alias("alias1").indexRouting("1").writeIndex(true)).setSettings(twoShardsSettings).get();
+
+        IndexRequest indexRequest = new IndexRequest("index3", "type", "id");
+        boolean indexWithRouting = randomBoolean();
+        if (indexWithRouting) {
+            indexRequest.routing("0");
+        }
+        indexRequest.source(Collections.singletonMap("foo", "bar"));
+        IndexRequest indexRequestWithAlias = new IndexRequest("alias1", "type", "id");
+        indexRequestWithAlias.source(Collections.singletonMap("foo", "baz"));
+        BulkResponse bulkResponse = client().prepareBulk()
+            .add(indexRequest).add(indexRequestWithAlias).get();
+        assertThat(bulkResponse.getItems()[0].getResponse().getIndex(), equalTo("index3"));
+        assertThat(bulkResponse.getItems()[0].getResponse().getShardId().getId(), equalTo(1));
+        assertThat(bulkResponse.getItems()[0].getResponse().getVersion(), equalTo(1L));
+        assertThat(bulkResponse.getItems()[0].getResponse().status(), equalTo(RestStatus.CREATED));
+        assertThat(bulkResponse.getItems()[1].getResponse().getIndex(), equalTo("index3"));
+        assertThat(bulkResponse.getItems()[1].getResponse().getShardId().getId(), equalTo(0));
+        assertThat(bulkResponse.getItems()[1].getResponse().getVersion(), equalTo(1L));
+        assertThat(bulkResponse.getItems()[1].getResponse().status(), equalTo(RestStatus.CREATED));
+        GetRequestBuilder getBuilder = client().prepareGet("index3", "type", "id");
+        if (indexWithRouting) {
+            getBuilder.setRouting("0");
+        }
+        assertThat(getBuilder.get().getSource().get("foo"), equalTo("bar"));
+        assertThat(client().prepareGet("index3", "type", "id").setRouting("1").get().getSource().get("foo"), equalTo("baz"));
+
+        client().prepareBulk().add(client().prepareUpdate("alias1", "type", "id").setDoc("foo", "updated")).get();
+        assertThat(getBuilder.get().getSource().get("foo"), equalTo("bar"));
+        assertThat(client().prepareGet("index3", "type", "id").setRouting("1").get().getSource().get("foo"), equalTo("updated"));
+        client().prepareBulk().add(client().prepareDelete("alias1", "type", "id")).get();
+        assertThat(getBuilder.get().getSource().get("foo"), equalTo("bar"));
+        assertFalse(client().prepareGet("index3", "type", "id").setRouting("1").get().isExists());
+    }
 }

server/src/test/java/org/elasticsearch/action/bulk/TransportBulkActionTests.java

@@ -66,7 +66,6 @@ public class TransportBulkActionTests extends ESTestCase {
     private ThreadPool threadPool;
 
     private TestTransportBulkAction bulkAction;
-    private TransportShardBulkAction shardBulkAction;
 
     class TestTransportBulkAction extends TransportBulkAction {
 
@@ -162,7 +161,6 @@ public void testDeleteNonExistingDocExternalGteVersionCreatesIndex() throws Exce
     }
 
     public void testRoutingResolvesToWriteIndexAliasMetaData() throws Exception {
-        ClusterState oldState = clusterService.state();
         clusterService.submitStateUpdateTask("_update", new ClusterStateUpdateTask() {
             @Override
             public ClusterState execute(ClusterState currentState) {

server/src/test/java/org/elasticsearch/aliases/IndexAliasesIT.java

@@ -94,7 +94,9 @@ public void testAliases() throws Exception {
         IllegalArgumentException exception = expectThrows(IllegalArgumentException.class,
             () -> client().index(indexRequest("alias1").type("type1").id("1").source(source("2", "test"),
                 XContentType.JSON)).actionGet());
-        assertThat(exception.getMessage(), equalTo("Alias [alias1] points to an index [test] with [is_write_index=false]"));
+        assertThat(exception.getMessage(), equalTo("no write index is defined for alias [alias1]." +
+            " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple" +
+            " indices without one being designated as a write index"));
 
         logger.info("--> aliasing index [test] with [alias1]");
         assertAcked(admin().indices().prepareAliases().addAlias("test", "alias1"));
@@ -116,14 +118,16 @@ public void testAliases() throws Exception {
         exception = expectThrows(IllegalArgumentException.class,
             () -> client().index(indexRequest("alias1").type("type1").id("1").source(source("2", "test"),
                 XContentType.JSON)).actionGet());
-        assertThat(exception.getMessage(),
-            equalTo("Alias [alias1] points to multiple indices with none set as a write-index [is_write_index=true]"));
+        assertThat(exception.getMessage(), equalTo("no write index is defined for alias [alias1]." +
+            " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple" +
+            " indices without one being designated as a write index"));
 
         logger.info("--> deleting against [alias1], should fail now");
         exception = expectThrows(IllegalArgumentException.class,
             () -> client().delete(deleteRequest("alias1").type("type1").id("1")).actionGet());
-        assertThat(exception.getMessage(),
-            equalTo("Alias [alias1] points to multiple indices with none set as a write-index [is_write_index=true]"));
+        assertThat(exception.getMessage(), equalTo("no write index is defined for alias [alias1]." +
+            " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple" +
+            " indices without one being designated as a write index"));
 
         logger.info("--> remove aliasing index [test_x] with [alias1]");
         assertAcked(admin().indices().prepareAliases().removeAlias("test_x", "alias1"));

server/src/test/java/org/elasticsearch/cluster/metadata/IndexNameExpressionResolverTests.java

@@ -1107,8 +1107,9 @@ public void testConcreteWriteIndexWithNoWriteIndexWithSingleIndex() {
             new UpdateRequest("test-alias", "_type", "_id"), new DeleteRequest("test-alias"));
         IllegalArgumentException exception = expectThrows(IllegalArgumentException.class,
             () -> indexNameExpressionResolver.concreteWriteIndex(state, request));
-        assertThat(exception.getMessage(),
-            equalTo("Alias [test-alias] points to an index [test-0] with [is_write_index=false]"));
+        assertThat(exception.getMessage(), equalTo("no write index is defined for alias [test-alias]." +
+                " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple" +
+                " indices without one being designated as a write index"));
     }
 
     public void testConcreteWriteIndexWithNoWriteIndexWithMultipleIndices() {
@@ -1126,16 +1127,18 @@ public void testConcreteWriteIndexWithNoWriteIndexWithMultipleIndices() {
             new UpdateRequest("test-alias", "_type", "_id"), new DeleteRequest("test-alias"));
         IllegalArgumentException exception = expectThrows(IllegalArgumentException.class,
             () -> indexNameExpressionResolver.concreteWriteIndex(state, request));
-        assertThat(exception.getMessage(),
-            equalTo("Alias [test-alias] points to multiple indices with none set as a write-index [is_write_index=true]"));
+        assertThat(exception.getMessage(), equalTo("no write index is defined for alias [test-alias]." +
+            " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple" +
+            " indices without one being designated as a write index"));
     }
 
     public void testAliasResolutionNotAllowingMultipleIndices() {
+        boolean test0WriteIndex = randomBoolean();
         MetaData.Builder mdBuilder = MetaData.builder()
             .put(indexBuilder("test-0").state(State.OPEN)
-                .putAlias(AliasMetaData.builder("test-alias").writeIndex(randomFrom(false, null))))
+                .putAlias(AliasMetaData.builder("test-alias").writeIndex(randomFrom(test0WriteIndex, null))))
             .put(indexBuilder("test-1").state(State.OPEN)
-                .putAlias(AliasMetaData.builder("test-alias").writeIndex(randomFrom(false, null))));
+                .putAlias(AliasMetaData.builder("test-alias").writeIndex(randomFrom(!test0WriteIndex, null))));
         ClusterState state = ClusterState.builder(new ClusterName("_name")).metaData(mdBuilder).build();
         String[] strings = indexNameExpressionResolver
             .indexAliases(state, "test-0", x -> true, true, "test-*");

server/src/test/java/org/elasticsearch/cluster/metadata/MetaDataTests.java

@@ -187,14 +187,16 @@ public void testResolveIndexRouting() {
     }
 
     public void testResolveWriteIndexRouting() {
+        boolean aliasZeroWrite = randomBoolean();
         IndexMetaData.Builder builder = IndexMetaData.builder("index")
             .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
             .numberOfShards(1)
             .numberOfReplicas(0)
-            .putAlias(AliasMetaData.builder("alias0").build())
+            .putAlias(AliasMetaData.builder("alias0").writeIndex(aliasZeroWrite).build())
             .putAlias(AliasMetaData.builder("alias1").routing("1").build())
             .putAlias(AliasMetaData.builder("alias2").routing("1,2").build())
-            .putAlias(AliasMetaData.builder("alias3").writeIndex(false).build());
+            .putAlias(AliasMetaData.builder("alias3").writeIndex(false).build())
+            .putAlias(AliasMetaData.builder("alias4").routing("1,2").writeIndex(true).build());
         MetaData metaData = MetaData.builder().put(builder).build();
 
         // no alias, no index
@@ -222,6 +224,9 @@ public void testResolveWriteIndexRouting() {
         exception = expectThrows(IllegalArgumentException.class, () -> metaData.resolveWriteIndexRouting("1", "alias2"));
         assertThat(exception.getMessage(),
             is("index/alias [alias2] provided with routing value [1,2] that resolved to several routing values, rejecting operation"));
+        exception = expectThrows(IllegalArgumentException.class, () -> metaData.resolveWriteIndexRouting(randomFrom("1", null), "alias4"));
+        assertThat(exception.getMessage(),
+            is("index/alias [alias4] provided with routing value [1,2] that resolved to several routing values, rejecting operation"));
 
         // alias with no write index
         exception = expectThrows(IllegalArgumentException.class, () -> metaData.resolveWriteIndexRouting("1", "alias3"));
@@ -234,7 +239,7 @@ public void testResolveWriteIndexRouting() {
             .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
             .numberOfShards(1)
             .numberOfReplicas(0)
-            .putAlias(AliasMetaData.builder("alias0").writeIndex(true).build())
+            .putAlias(AliasMetaData.builder("alias0").writeIndex(!aliasZeroWrite).build())
             .putAlias(AliasMetaData.builder("alias1").routing("0").writeIndex(true).build())
             .putAlias(AliasMetaData.builder("alias2").writeIndex(true).build());
         MetaData metaDataTwoIndices = MetaData.builder(metaData).put(builder2).build();

server/src/test/java/org/elasticsearch/get/GetActionIT.java

@@ -29,6 +29,7 @@
 import org.elasticsearch.action.get.MultiGetRequest;
 import org.elasticsearch.action.get.MultiGetRequestBuilder;
 import org.elasticsearch.action.get.MultiGetResponse;
+import org.elasticsearch.action.index.IndexResponse;
 import org.elasticsearch.action.support.DefaultShardOperationFailedException;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.Strings;
@@ -39,6 +40,7 @@
 import org.elasticsearch.common.xcontent.XContentType;
 import org.elasticsearch.index.engine.VersionConflictEngineException;
 import org.elasticsearch.plugins.Plugin;
+import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.test.ESIntegTestCase;
 import org.elasticsearch.test.InternalSettingsPlugin;
 
@@ -51,6 +53,7 @@
 import static java.util.Collections.singleton;
 import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
+import static org.hamcrest.Matchers.endsWith;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasKey;
 import static org.hamcrest.Matchers.instanceOf;
@@ -192,6 +195,25 @@ public void testSimpleGet() {
         assertThat(response.isExists(), equalTo(false));
     }
 
+    public void testGetWithAliasPointingToMultipleIndices() {
+        client().admin().indices().prepareCreate("index1")
+            .addAlias(new Alias("alias1").indexRouting("0")).get();
+        if (randomBoolean()) {
+            client().admin().indices().prepareCreate("index2")
+                .addAlias(new Alias("alias1").indexRouting("0").writeIndex(randomFrom(false, null))).get();
+        } else {
+            client().admin().indices().prepareCreate("index3")
+                .addAlias(new Alias("alias1").indexRouting("1").writeIndex(true)).get();
+        }
+        IndexResponse indexResponse = client().prepareIndex("index1", "type", "id")
+            .setSource(Collections.singletonMap("foo", "bar")).get();
+        assertThat(indexResponse.status().getStatus(), equalTo(RestStatus.CREATED.getStatus()));
+
+        IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, () ->
+            client().prepareGet("alias1", "type", "_alias_id").get());
+        assertThat(exception.getMessage(), endsWith("can't execute a single index op"));
+    }
+
     private static String indexOrAlias() {
         return randomBoolean() ? "test" : "alias";
     }