Enforce Completion Context Limit

server/src/main/java/org/elasticsearch/index/mapper/CompletionFieldMapper.java

@@ -18,6 +18,7 @@
  */
 package org.elasticsearch.index.mapper;
 
+import org.apache.logging.log4j.LogManager;
 import org.apache.lucene.codecs.PostingsFormat;
 import org.apache.lucene.index.IndexableField;
 import org.apache.lucene.index.Term;
@@ -31,8 +32,10 @@
 import org.apache.lucene.search.suggest.document.RegexCompletionQuery;
 import org.apache.lucene.search.suggest.document.SuggestField;
 import org.elasticsearch.Version;
+import org.elasticsearch.cluster.metadata.IndexMetaData;
 import org.elasticsearch.common.ParseField;
 import org.elasticsearch.common.ParsingException;
+import org.elasticsearch.common.logging.DeprecationLogger;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.Fuzziness;
 import org.elasticsearch.common.util.set.Sets;
@@ -85,6 +88,11 @@
 public class CompletionFieldMapper extends FieldMapper implements ArrayValueMapperParser {
     public static final String CONTENT_TYPE = "completion";
 
+    /**
+     * Maximum allowed number of completion contexts in a mapping.
+     */
+    static final int COMPLETION_CONTEXTS_LIMIT = 10;
+
     public static class Defaults {
         public static final MappedFieldType FIELD_TYPE = new CompletionFieldType();
         static {
@@ -354,6 +362,8 @@ public static class Builder extends FieldMapper.Builder<Builder, CompletionField
         private boolean preserveSeparators = Defaults.DEFAULT_PRESERVE_SEPARATORS;
         private boolean preservePositionIncrements = Defaults.DEFAULT_POSITION_INCREMENTS;
 
+        private static final DeprecationLogger deprecationLogger = new DeprecationLogger(LogManager.getLogger(Builder.class));
+
         /**
          * @param name of the completion field to build
          */
@@ -397,6 +407,7 @@ public Builder preservePositionIncrements(boolean preservePositionIncrements) {
 
         @Override
         public CompletionFieldMapper build(BuilderContext context) {
+            checkCompletionContextsLimit(context);
             setupFieldType(context);
             CompletionFieldType completionFieldType = (CompletionFieldType) this.fieldType;
             completionFieldType.setContextMappings(contextMappings);
@@ -405,6 +416,20 @@ public CompletionFieldMapper build(BuilderContext context) {
             return new CompletionFieldMapper(name, this.fieldType, context.indexSettings(),
                 multiFieldsBuilder.build(this, context), copyTo, maxInputLength);
         }
+
+        private void checkCompletionContextsLimit(BuilderContext context) {
+            if (this.contextMappings != null && this.contextMappings.size() > COMPLETION_CONTEXTS_LIMIT) {
+                if (context.indexCreatedVersion().onOrAfter(Version.V_8_0_0)) {
+                    throw new IllegalArgumentException(
+                        "Limit of completion field contexts [" + COMPLETION_CONTEXTS_LIMIT + "] has been exceeded");
+                } else {
+                    deprecationLogger.deprecated("You have defined more than [" + COMPLETION_CONTEXTS_LIMIT + "] completion contexts" +
+                        " in the mapping for index [" + context.indexSettings().get(IndexMetaData.SETTING_INDEX_PROVIDED_NAME) + "]. " +
+                        "The maximum allowed number of completion contexts in a mapping will be limited to " +
+                        "[" + COMPLETION_CONTEXTS_LIMIT + "] starting in version [8.0].");
+                }
+            }
+        }
     }
 
     private int maxInputLength;

server/src/test/java/org/elasticsearch/index/mapper/CompletionFieldMapperTests.java

@@ -908,6 +908,28 @@ public void testEmptyName() throws IOException {
         assertThat(e.getMessage(), containsString("name cannot be empty string"));
     }
 
+    public void testLimitOfContextMappings() throws Throwable {
+        final String index = "test";
+        XContentBuilder mappingBuilder = XContentFactory.jsonBuilder().startObject().startObject("properties")
+            .startObject("suggest").field("type", "completion").startArray("contexts");
+        for (int i = 0; i < CompletionFieldMapper.COMPLETION_CONTEXTS_LIMIT + 1; i++) {
+            mappingBuilder.startObject();
+            mappingBuilder.field("name", Integer.toString(i));
+            mappingBuilder.field("type", "category");
+            mappingBuilder.endObject();
+        }
+
+        mappingBuilder.endArray().endObject().endObject().endObject();
+        String mappings = Strings.toString(mappingBuilder);
+
+        IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> {
+            createIndex(index).mapperService().documentMapperParser().parse("type1", new CompressedXContent(mappings));
+        });
+        assertTrue(e.getMessage(),
+            e.getMessage().contains("Limit of completion field contexts [" +
+                CompletionFieldMapper.COMPLETION_CONTEXTS_LIMIT + "] has been exceeded"));
+    }
+
     private Matcher<IndexableField> suggestField(String value) {
         return Matchers.allOf(hasProperty(IndexableField::stringValue, equalTo(value)),
             Matchers.instanceOf(SuggestField.class));