Remove local discovery in favor of a simpler MockZenPings

core/src/main/java/org/elasticsearch/cluster/ClusterState.java

@@ -52,7 +52,6 @@
 import org.elasticsearch.common.xcontent.XContentFactory;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.discovery.Discovery;
-import org.elasticsearch.discovery.local.LocalDiscovery;
 import org.elasticsearch.discovery.zen.publish.PublishClusterStateAction;
 
 import java.io.IOException;
@@ -72,8 +71,7 @@
  * single thread and controlled by the {@link ClusterService}. After every update the
  * {@link Discovery#publish} method publishes new version of the cluster state to all other nodes in the
  * cluster.  The actual publishing mechanism is delegated to the {@link Discovery#publish} method and depends on
- * the type of discovery. For example, for local discovery it is implemented by the {@link LocalDiscovery#publish}
- * method. In the Zen Discovery it is handled in the {@link PublishClusterStateAction#publish} method. The
+ * the type of discovery. In the Zen Discovery it is handled in the {@link PublishClusterStateAction#publish} method. The
  * publishing mechanism can be overridden by other discovery.
  * <p>
  * The cluster state implements the {@link Diffable} interface in order to support publishing of cluster state

core/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/MaxRetryAllocationDecider.java

@@ -54,24 +54,30 @@ public MaxRetryAllocationDecider(Settings settings) {
 
     @Override
     public Decision canAllocate(ShardRouting shardRouting, RoutingAllocation allocation) {
-        UnassignedInfo unassignedInfo = shardRouting.unassignedInfo();
+        final UnassignedInfo unassignedInfo = shardRouting.unassignedInfo();
+        final Decision decision;
         if (unassignedInfo != null && unassignedInfo.getNumFailedAllocations() > 0) {
             final IndexMetaData indexMetaData = allocation.metaData().getIndexSafe(shardRouting.index());
             final int maxRetry = SETTING_ALLOCATION_MAX_RETRY.get(indexMetaData.getSettings());
             if (allocation.isRetryFailed()) { // manual allocation - retry
                 // if we are called via the _reroute API we ignore the failure counter and try to allocate
                 // this improves the usability since people don't need to raise the limits to issue retries since a simple _reroute call is
                 // enough to manually retry.
-                return allocation.decision(Decision.YES, NAME, "shard has already failed allocating ["
+                decision = allocation.decision(Decision.YES, NAME, "shard has already failed allocating ["
                     + unassignedInfo.getNumFailedAllocations() + "] times vs. [" + maxRetry + "] retries allowed "
                     + unassignedInfo.toString() + " - retrying once on manual allocation");
             } else if (unassignedInfo.getNumFailedAllocations() >= maxRetry) {
-                return allocation.decision(Decision.NO, NAME, "shard has already failed allocating ["
+                decision = allocation.decision(Decision.NO, NAME, "shard has already failed allocating ["
                     + unassignedInfo.getNumFailedAllocations() + "] times vs. [" + maxRetry + "] retries allowed "
                     + unassignedInfo.toString() + " - manually call [/_cluster/reroute?retry_failed=true] to retry");
+            } else {
+                decision = allocation.decision(Decision.YES, NAME, "shard has already failed allocating ["
+                    + unassignedInfo.getNumFailedAllocations() + "] times but [" + maxRetry + "] retries are allowed");
             }
+        } else {
+            decision = allocation.decision(Decision.YES, NAME, "shard has no previous failures");
         }
-        return allocation.decision(Decision.YES, NAME, "shard has no previous failures");
+        return decision;
     }
 
     @Override

core/src/main/java/org/elasticsearch/common/util/ExtensionPoint.java

@@ -200,6 +200,10 @@ protected void bindExtensions(Binder binder) {
                 allocationMultibinder.addBinding().to(clazz);
             }
         }
+
+        public boolean isEmpty() {
+            return extensions.isEmpty();
+        }
     }
 
     /**

core/src/main/java/org/elasticsearch/discovery/DiscoveryModule.java

@@ -25,7 +25,6 @@
 import org.elasticsearch.common.settings.Setting.Property;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.util.ExtensionPoint;
-import org.elasticsearch.discovery.local.LocalDiscovery;
 import org.elasticsearch.discovery.zen.ElectMasterService;
 import org.elasticsearch.discovery.zen.ZenDiscovery;
 import org.elasticsearch.discovery.zen.ping.ZenPing;
@@ -59,11 +58,9 @@ public class DiscoveryModule extends AbstractModule {
 
     public DiscoveryModule(Settings settings) {
         this.settings = settings;
-        addDiscoveryType("local", LocalDiscovery.class);
+        addDiscoveryType("none", NoneDiscovery.class);
         addDiscoveryType("zen", ZenDiscovery.class);
         addElectMasterService("zen", ElectMasterService.class);
-        // always add the unicast hosts, or things get angry!
-        addZenPing(UnicastZenPing.class);
     }
 
     /**
@@ -113,7 +110,7 @@ protected void configure() {
             throw new IllegalArgumentException("Unknown Discovery type [" + discoveryType + "]");
         }
 
-        if (discoveryType.equals("local") == false) {
+        if (discoveryType.equals("none") == false) {
             String masterServiceTypeKey = ZEN_MASTER_SERVICE_TYPE_SETTING.get(settings);
             final Class<? extends ElectMasterService> masterService = masterServiceType.get(masterServiceTypeKey);
             if (masterService == null) {
@@ -130,6 +127,9 @@ protected void configure() {
                     unicastHostProviders.getOrDefault(discoveryType, Collections.emptyList())) {
                 unicastHostsProviderMultibinder.addBinding().to(unicastHostProvider);
             }
+            if (zenPings.isEmpty()) {
+                zenPings.registerExtension(UnicastZenPing.class);
+            }
             zenPings.bind(binder());
         }
         bind(Discovery.class).to(discoveryClass).asEagerSingleton();

core/src/main/java/org/elasticsearch/discovery/NoneDiscovery.java

@@ -0,0 +1,102 @@
+/*
+ * 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.discovery;
+
+import org.elasticsearch.cluster.ClusterChangedEvent;
+import org.elasticsearch.cluster.node.DiscoveryNode;
+import org.elasticsearch.cluster.routing.allocation.AllocationService;
+import org.elasticsearch.cluster.service.ClusterService;
+import org.elasticsearch.common.component.AbstractLifecycleComponent;
+import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.settings.ClusterSettings;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.discovery.zen.ElectMasterService;
+
+/**
+ * A {@link Discovery} implementation that is used by {@link org.elasticsearch.tribe.TribeService}. This implementation
+ * doesn't support any clustering features. Most notably {@link #startInitialJoin()} does nothing and
+ * {@link #publish(ClusterChangedEvent, AckListener)} is not supported.
+ */
+public class NoneDiscovery extends AbstractLifecycleComponent implements Discovery {
+
+    private final ClusterService clusterService;
+    private final DiscoverySettings discoverySettings;
+
+    @Inject
+    public NoneDiscovery(Settings settings, ClusterService clusterService, ClusterSettings clusterSettings) {
+        super(settings);
+        this.clusterService = clusterService;
+        this.discoverySettings = new DiscoverySettings(settings, clusterSettings);
+    }
+
+    @Override
+    public DiscoveryNode localNode() {
+        return clusterService.localNode();
+    }
+
+    @Override
+    public String nodeDescription() {
+        return clusterService.getClusterName().value() + "/" + clusterService.localNode().getId();
+    }
+
+    @Override
+    public void setAllocationService(AllocationService allocationService) {
+
+    }
+
+    @Override
+    public void publish(ClusterChangedEvent clusterChangedEvent, AckListener ackListener) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public DiscoveryStats stats() {
+        return null;
+    }
+
+    @Override
+    public DiscoverySettings getDiscoverySettings() {
+        return discoverySettings;
+    }
+
+    @Override
+    public void startInitialJoin() {
+
+    }
+
+    @Override
+    public int getMinimumMasterNodes() {
+        return ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.get(settings);
+    }
+
+    @Override
+    protected void doStart() {
+
+    }
+
+    @Override
+    protected void doStop() {
+
+    }
+
+    @Override
+    protected void doClose() {
+
+    }
+}