Allow to disable sending a refresh-mapping to master node

When a node processed an index request, which caused it to update its own mapping, then it sends that mapping to the master. While the master process it, that node receives a state that includes an older version of the mapping. Now, there is a conflict, its not bad (i.e. the cluster state will eventually have the correct mapping), but we send for a refresh just in case form that node to the master.

With a system that has extreme cases of updates and frequent mapping changes, it might make sense to disable this feature. The indices.cluster.send_refresh_mapping setting can be introduced to support that (note, this setting need to be set on the data nodes)

Note, sending refresh mapping is more important when the reverse happens, and for some reason, the mapping in the master is ahead, or in conflict, with the actual parsing of it in the actual node the index exists on. In this case, the refresh mapping will result in warning being logged on the master node.

closes elastic#4342

Author: kimchy

src/main/java/org/elasticsearch/indices/cluster/IndicesClusterStateService.java

@@ -109,9 +109,10 @@ static class FailedShard {
     }
 
     private final Object mutex = new Object();
-
     private final FailedEngineHandler failedEngineHandler = new FailedEngineHandler();
 
+    private final boolean sendRefreshMapping;
+
     @Inject
     public IndicesClusterStateService(Settings settings, IndicesService indicesService, ClusterService clusterService,
                                       ThreadPool threadPool, RecoveryTarget recoveryTarget,
@@ -127,6 +128,8 @@ public IndicesClusterStateService(Settings settings, IndicesService indicesServi
         this.nodeIndexCreatedAction = nodeIndexCreatedAction;
         this.nodeIndexDeletedAction = nodeIndexDeletedAction;
         this.nodeMappingRefreshAction = nodeMappingRefreshAction;
+
+        this.sendRefreshMapping = componentSettings.getAsBoolean("send_refresh_mapping", true);
     }
 
     @Override
@@ -374,9 +377,11 @@ private void applyMappings(ClusterChangedEvent event) {
                 }
             }
             if (typesToRefresh != null) {
-                nodeMappingRefreshAction.nodeMappingRefresh(event.state(),
-                        new NodeMappingRefreshAction.NodeMappingRefreshRequest(index, indexMetaData.uuid(),
-                                typesToRefresh.toArray(new String[typesToRefresh.size()]), event.state().nodes().localNodeId()));
+                if (sendRefreshMapping) {
+                    nodeMappingRefreshAction.nodeMappingRefresh(event.state(),
+                            new NodeMappingRefreshAction.NodeMappingRefreshRequest(index, indexMetaData.uuid(),
+                                    typesToRefresh.toArray(new String[typesToRefresh.size()]), event.state().nodes().localNodeId()));
+                }
             }
             // go over and remove mappings
             for (DocumentMapper documentMapper : mapperService) {
@@ -394,6 +399,13 @@ private boolean processMapping(String index, MapperService mapperService, String
             seenMappings.put(new Tuple<String, String>(index, mappingType), true);
         }
 
+        // refresh mapping can happen for 2 reasons. The first is less urgent, and happens when the mapping on this
+        // node is ahead of what there is in the cluster state (yet an update-mapping has been sent to it already,
+        // it just hasn't been processed yet and published). Eventually, the mappings will converge, and the refresh
+        // mapping sent is more of a safe keeping (assuming the update mapping failed to reach the master, ...)
+        // the second case is where the parsing/merging of the mapping from the metadata doesn't result in the same
+        // mapping, in this case, we send to the master to refresh its own version of the mappings (to conform with the
+        // merge version of it, which it does when refreshing the mappings), and warn log it.
         boolean requiresRefresh = false;
         try {
             if (!mapperService.hasMapping(mappingType)) {
@@ -403,7 +415,6 @@ private boolean processMapping(String index, MapperService mapperService, String
                 // we don't apply default, since it has been applied when the mappings were parsed initially
                 mapperService.merge(mappingType, mappingSource, false);
                 if (!mapperService.documentMapper(mappingType).mappingSource().equals(mappingSource)) {
-                    // this might happen when upgrading from 0.15 to 0.16
                     logger.debug("[{}] parsed mapping [{}], and got different sources\noriginal:\n{}\nparsed:\n{}", index, mappingType, mappingSource, mapperService.documentMapper(mappingType).mappingSource());
                     requiresRefresh = true;
                 }
@@ -418,7 +429,6 @@ private boolean processMapping(String index, MapperService mapperService, String
                     mapperService.merge(mappingType, mappingSource, false);
                     if (!mapperService.documentMapper(mappingType).mappingSource().equals(mappingSource)) {
                         requiresRefresh = true;
-                        // this might happen when upgrading from 0.15 to 0.16
                         logger.debug("[{}] parsed mapping [{}], and got different sources\noriginal:\n{}\nparsed:\n{}", index, mappingType, mappingSource, mapperService.documentMapper(mappingType).mappingSource());
                     }
                 }