Add validation for field alias mappings.

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

@@ -70,43 +70,80 @@ public FieldTypeLookup copyAndAddAll(String type,
             MappedFieldType fieldType = fieldMapper.fieldType();
             MappedFieldType fullNameFieldType = fullName.get(fieldType.name());
 
-            if (fullNameFieldType == null) {
-                // introduction of a new field
-                fullName = fullName.copyAndPut(fieldType.name(), fieldMapper.fieldType());
-            } else {
-                // modification of an existing field
-                checkCompatibility(fullNameFieldType, fieldType);
-                if (fieldType.equals(fullNameFieldType) == false) {
-                    fullName = fullName.copyAndPut(fieldType.name(), fieldMapper.fieldType());
-                }
+            if (!Objects.equals(fieldType, fullNameFieldType)) {
+                validateField(fullNameFieldType, fieldType, aliases);
+                fullName = fullName.copyAndPut(fieldType.name(), fieldType);
             }
         }
 
         for (FieldAliasMapper fieldAliasMapper : fieldAliasMappers) {
             String aliasName = fieldAliasMapper.name();
-            String fieldName = fieldAliasMapper.path();
-            aliases = aliases.copyAndPut(aliasName, fieldName);
+            String path = fieldAliasMapper.path();
+
+            validateAlias(aliasName, path, aliases, fullName);
+            aliases = aliases.copyAndPut(aliasName, path);
         }
 
         return new FieldTypeLookup(fullName, aliases);
     }
 
     /**
-     * Checks if the given field type is compatible with an existing field type.
-     * An IllegalArgumentException is thrown in case of incompatibility.
+     * Checks that the new field type is valid.
      */
-    private void checkCompatibility(MappedFieldType existingFieldType, MappedFieldType newFieldType) {
-        List<String> conflicts = new ArrayList<>();
-        existingFieldType.checkCompatibility(newFieldType, conflicts);
-        if (conflicts.isEmpty() == false) {
-            throw new IllegalArgumentException("Mapper for [" + newFieldType.name() + "] conflicts with existing mapping:\n" + conflicts.toString());
+    private void validateField(MappedFieldType existingFieldType,
+                               MappedFieldType newFieldType,
+                               CopyOnWriteHashMap<String, String> aliasToConcreteName) {
+        String fieldName = newFieldType.name();
+        if (aliasToConcreteName.containsKey(fieldName)) {
+            throw new IllegalArgumentException("The name for field [" + fieldName + "] has already" +
+                " been used to define a field alias.");
+        }
+
+        if (existingFieldType != null) {
+            List<String> conflicts = new ArrayList<>();
+            existingFieldType.checkCompatibility(newFieldType, conflicts);
+            if (conflicts.isEmpty() == false) {
+                throw new IllegalArgumentException("Mapper for [" + fieldName +
+                    "] conflicts with existing mapping:\n" + conflicts.toString());
+            }
+        }
+    }
+
+    /**
+     * Checks that the new field alias is valid.
+     *
+     * Note that this method assumes that new concrete fields have already been processed, so that it
+     * can verify that an alias refers to an existing concrete field.
+     */
+    private void validateAlias(String aliasName,
+                               String path,
+                               CopyOnWriteHashMap<String, String> aliasToConcreteName,
+                               CopyOnWriteHashMap<String, MappedFieldType> fullNameToFieldType) {
+        if (fullNameToFieldType.containsKey(aliasName)) {
+            throw new IllegalArgumentException("The name for field alias [" + aliasName + "] has already" +
+                " been used to define a concrete field.");
+        }
+
+        if (path.equals(aliasName)) {
+            throw new IllegalArgumentException("Invalid [path] value [" + path + "] for field alias [" +
+                aliasName + "]: an alias cannot refer to itself.");
+        }
+
+        if (aliasToConcreteName.containsKey(path)) {
+            throw new IllegalArgumentException("Invalid [path] value [" + path + "] for field alias [" +
+                aliasName + "]: an alias cannot refer to another alias.");
+        }
+
+        if (!fullNameToFieldType.containsKey(path)) {
+            throw new IllegalArgumentException("Invalid [path] value [" + path + "] for field alias [" +
+                aliasName + "]: an alias must refer to an existing field in the mappings.");
         }
     }
 
     /** Returns the field for the given field */
     public MappedFieldType get(String field) {
-        String resolvedField = aliasToConcreteName.getOrDefault(field, field);
-        return fullNameToFieldType.get(resolvedField);
+        String concreteField = aliasToConcreteName.getOrDefault(field, field);
+        return fullNameToFieldType.get(concreteField);
     }
 
     /**

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

@@ -0,0 +1,214 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.index.mapper;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Stream;
+
+/**
+ * A utility class that helps validate certain aspects of a mappings update.
+ */
+class MapperMergeValidator {
+
+    /**
+     * Validates the overall structure of the mapping addition, including whether
+     * duplicate fields are present, and if the provided fields have already been
+     * defined with a different data type.
+     *
+     * @param type The mapping type, for use in error messages.
+     * @param objectMappers The newly added object mappers.
+     * @param fieldMappers The newly added field mappers.
+     * @param fieldAliasMappers The newly added field alias mappers.
+     * @param fullPathObjectMappers All object mappers, indexed by their full path.
+     * @param fieldTypes All field and field alias mappers, collected into a lookup structure.
+     */
+    public static void validateMapperStructure(String type,
+                                               Collection<ObjectMapper> objectMappers,
+                                               Collection<FieldMapper> fieldMappers,
+                                               Collection<FieldAliasMapper> fieldAliasMappers,
+                                               Map<String, ObjectMapper> fullPathObjectMappers,
+                                               FieldTypeLookup fieldTypes) {
+        checkFieldUniqueness(type, objectMappers, fieldMappers,
+            fieldAliasMappers, fullPathObjectMappers, fieldTypes);
+        checkObjectsCompatibility(objectMappers, fullPathObjectMappers);
+    }
+
+    private static void checkFieldUniqueness(String type,
+                                             Collection<ObjectMapper> objectMappers,
+                                             Collection<FieldMapper> fieldMappers,
+                                             Collection<FieldAliasMapper> fieldAliasMappers,
+                                             Map<String, ObjectMapper> fullPathObjectMappers,
+                                             FieldTypeLookup fieldTypes) {
+
+        // first check within mapping
+        Set<String> objectFullNames = new HashSet<>();
+        for (ObjectMapper objectMapper : objectMappers) {
+            String fullPath = objectMapper.fullPath();
+            if (objectFullNames.add(fullPath) == false) {
+                throw new IllegalArgumentException("Object mapper [" + fullPath + "] is defined twice in mapping for type [" + type + "]");
+            }
+        }
+
+        Set<String> fieldNames = new HashSet<>();
+        Stream.concat(fieldMappers.stream(), fieldAliasMappers.stream())
+            .forEach(mapper -> {
+                String name = mapper.name();
+                if (objectFullNames.contains(name)) {
+                    throw new IllegalArgumentException("Field [" + name + "] is defined both as an object and a field in [" + type + "]");
+                } else if (fieldNames.add(name) == false) {
+                    throw new IllegalArgumentException("Field [" + name + "] is defined twice in [" + type + "]");
+                }
+            });
+
+        // then check other types
+        for (String fieldName : fieldNames) {
+            if (fullPathObjectMappers.containsKey(fieldName)) {
+                throw new IllegalArgumentException("[" + fieldName + "] is defined as a field in mapping [" + type
+                    + "] but this name is already used for an object in other types");
+            }
+        }
+
+        for (String objectPath : objectFullNames) {
+            if (fieldTypes.get(objectPath) != null) {
+                throw new IllegalArgumentException("[" + objectPath + "] is defined as an object in mapping [" + type
+                    + "] but this name is already used for a field in other types");
+            }
+        }
+    }
+
+    private static void checkObjectsCompatibility(Collection<ObjectMapper> objectMappers,
+                                                  Map<String, ObjectMapper> fullPathObjectMappers) {
+        for (ObjectMapper newObjectMapper : objectMappers) {
+            ObjectMapper existingObjectMapper = fullPathObjectMappers.get(newObjectMapper.fullPath());
+            if (existingObjectMapper != null) {
+                // simulate a merge and ignore the result, we are just interested
+                // in exceptions here
+                existingObjectMapper.merge(newObjectMapper);
+            }
+        }
+    }
+
+    /**
+     * Verifies that each field reference, e.g. the value of copy_to or the target
+     * of a field alias, corresponds to a valid part of the mapping.
+     *
+     * @param fieldMappers The newly added field mappers.
+     * @param fieldAliasMappers The newly added field alias mappers.
+     * @param fullPathObjectMappers All object mappers, indexed by their full path.
+     * @param fieldTypes All field and field alias mappers, collected into a lookup structure.
+     */
+    public static void validateFieldReferences(List<FieldMapper> fieldMappers,
+                                               List<FieldAliasMapper> fieldAliasMappers,
+                                               Map<String, ObjectMapper> fullPathObjectMappers,
+                                               FieldTypeLookup fieldTypes) {
+        validateCopyTo(fieldMappers, fullPathObjectMappers, fieldTypes);
+        validateFieldAliasTargets(fieldAliasMappers, fullPathObjectMappers);
+    }
+
+    private static void validateCopyTo(List<FieldMapper> fieldMappers,
+                                       Map<String, ObjectMapper> fullPathObjectMappers,
+                                       FieldTypeLookup fieldTypes) {
+        for (FieldMapper mapper : fieldMappers) {
+            if (mapper.copyTo() != null && mapper.copyTo().copyToFields().isEmpty() == false) {
+                String sourceParent = parentObject(mapper.name());
+                if (sourceParent != null && fieldTypes.get(sourceParent) != null) {
+                    throw new IllegalArgumentException("[copy_to] may not be used to copy from a multi-field: [" + mapper.name() + "]");
+                }
+
+                final String sourceScope = getNestedScope(mapper.name(), fullPathObjectMappers);
+                for (String copyTo : mapper.copyTo().copyToFields()) {
+                    String copyToParent = parentObject(copyTo);
+                    if (copyToParent != null && fieldTypes.get(copyToParent) != null) {
+                        throw new IllegalArgumentException("[copy_to] may not be used to copy to a multi-field: [" + copyTo + "]");
+                    }
+
+                    if (fullPathObjectMappers.containsKey(copyTo)) {
+                        throw new IllegalArgumentException("Cannot copy to field [" + copyTo + "] since it is mapped as an object");
+                    }
+
+                    final String targetScope = getNestedScope(copyTo, fullPathObjectMappers);
+                    checkNestedScopeCompatibility(sourceScope, targetScope);
+                }
+            }
+        }
+    }
+
+    private static void validateFieldAliasTargets(List<FieldAliasMapper> fieldAliasMappers,
+                                                  Map<String, ObjectMapper> fullPathObjectMappers) {
+        for (FieldAliasMapper mapper : fieldAliasMappers) {
+            String aliasName = mapper.name();
+            String path = mapper.path();
+
+            String aliasScope = getNestedScope(aliasName, fullPathObjectMappers);
+            String pathScope = getNestedScope(path, fullPathObjectMappers);
+
+            if (!Objects.equals(aliasScope, pathScope)) {
+                StringBuilder message = new StringBuilder("Invalid [path] value [" + path + "] for field alias [" +
+                    aliasName + "]: an alias must have the same nested scope as its target. ");
+                message.append(aliasScope == null
+                    ? "The alias is not nested"
+                    : "The alias's nested scope is [" + aliasScope + "]");
+                message.append(", but ");
+                message.append(pathScope == null
+                    ? "the target is not nested."
+                    : "the target's nested scope is [" + pathScope + "].");
+                throw new IllegalArgumentException(message.toString());
+            }
+        }
+    }
+
+    private static String getNestedScope(String path, Map<String, ObjectMapper> fullPathObjectMappers) {
+        for (String parentPath = parentObject(path); parentPath != null; parentPath = parentObject(parentPath)) {
+            ObjectMapper objectMapper = fullPathObjectMappers.get(parentPath);
+            if (objectMapper != null && objectMapper.nested().isNested()) {
+                return parentPath;
+            }
+        }
+        return null;
+    }
+
+    private static void checkNestedScopeCompatibility(String source, String target) {
+        boolean targetIsParentOfSource;
+        if (source == null || target == null) {
+            targetIsParentOfSource = target == null;
+        } else {
+            targetIsParentOfSource = source.equals(target) || source.startsWith(target + ".");
+        }
+        if (targetIsParentOfSource == false) {
+            throw new IllegalArgumentException(
+                "Illegal combination of [copy_to] and [nested] mappings: [copy_to] may only copy data to the current nested " +
+                    "document or any of its parents, however one [copy_to] directive is trying to copy data from nested object [" +
+                    source + "] to [" + target + "]");
+        }
+    }
+
+    private static String parentObject(String field) {
+        int lastDot = field.lastIndexOf('.');
+        if (lastDot == -1) {
+            return null;
+        }
+        return field.substring(0, lastDot);
+    }
+}