Introduce transport API for cluster bootstrapping

server/src/main/java/org/elasticsearch/action/ActionModule.java

@@ -23,6 +23,10 @@
 import org.apache.logging.log4j.LogManager;
 import org.elasticsearch.action.admin.cluster.allocation.ClusterAllocationExplainAction;
 import org.elasticsearch.action.admin.cluster.allocation.TransportClusterAllocationExplainAction;
+import org.elasticsearch.action.admin.cluster.bootstrap.BootstrapClusterAction;
+import org.elasticsearch.action.admin.cluster.bootstrap.GetDiscoveredNodesAction;
+import org.elasticsearch.action.admin.cluster.bootstrap.TransportBootstrapClusterAction;
+import org.elasticsearch.action.admin.cluster.bootstrap.TransportGetDiscoveredNodesAction;
 import org.elasticsearch.action.admin.cluster.health.ClusterHealthAction;
 import org.elasticsearch.action.admin.cluster.health.TransportClusterHealthAction;
 import org.elasticsearch.action.admin.cluster.node.hotthreads.NodesHotThreadsAction;
@@ -422,6 +426,8 @@ public <Request extends ActionRequest, Response extends ActionResponse> void reg
         actions.register(GetTaskAction.INSTANCE, TransportGetTaskAction.class);
         actions.register(CancelTasksAction.INSTANCE, TransportCancelTasksAction.class);
 
+        actions.register(GetDiscoveredNodesAction.INSTANCE, TransportGetDiscoveredNodesAction.class);
+        actions.register(BootstrapClusterAction.INSTANCE, TransportBootstrapClusterAction.class);
         actions.register(ClusterAllocationExplainAction.INSTANCE, TransportClusterAllocationExplainAction.class);
         actions.register(ClusterStatsAction.INSTANCE, TransportClusterStatsAction.class);
         actions.register(ClusterStateAction.INSTANCE, TransportClusterStateAction.class);

server/src/main/java/org/elasticsearch/action/admin/cluster/bootstrap/BootstrapClusterAction.java

@@ -0,0 +1,41 @@
+/*
+ * 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.action.admin.cluster.bootstrap;
+
+import org.elasticsearch.action.Action;
+import org.elasticsearch.common.io.stream.Writeable.Reader;
+
+public class BootstrapClusterAction extends Action<BootstrapClusterResponse> {
+    public static final BootstrapClusterAction INSTANCE = new BootstrapClusterAction();
+    public static final String NAME = "cluster:admin/bootstrap_cluster";
+
+    private BootstrapClusterAction() {
+        super(NAME);
+    }
+
+    @Override
+    public BootstrapClusterResponse newResponse() {
+        throw new UnsupportedOperationException("usage of Streamable is to be replaced by Writeable");
+    }
+
+    @Override
+    public Reader<BootstrapClusterResponse> getResponseReader() {
+        return BootstrapClusterResponse::new;
+    }
+}

server/src/main/java/org/elasticsearch/action/admin/cluster/bootstrap/BootstrapClusterRequest.java

@@ -0,0 +1,65 @@
+/*
+ * 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.action.admin.cluster.bootstrap;
+
+import org.elasticsearch.action.ActionRequest;
+import org.elasticsearch.action.ActionRequestValidationException;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+
+/**
+ * Request to set the initial configuration of master-eligible nodes in a cluster so that the very first master election can take place.
+ */
+public class BootstrapClusterRequest extends ActionRequest {
+    private final BootstrapConfiguration bootstrapConfiguration;
+
+    public BootstrapClusterRequest(BootstrapConfiguration bootstrapConfiguration) {
+        this.bootstrapConfiguration = bootstrapConfiguration;
+    }
+
+    public BootstrapClusterRequest(StreamInput in) throws IOException {
+        super(in);
+        bootstrapConfiguration = new BootstrapConfiguration(in);
+    }
+
+    /**
+     * @return the bootstrap configuration: the initial set of master-eligible nodes whose votes are counted in elections.
+     */
+    public BootstrapConfiguration getBootstrapConfiguration() {
+        return bootstrapConfiguration;
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        return null;
+    }
+
+    @Override
+    public void readFrom(StreamInput in) throws IOException {
+        throw new UnsupportedOperationException("usage of Streamable is to be replaced by Writeable");
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        bootstrapConfiguration.writeTo(out);
+    }
+}

server/src/main/java/org/elasticsearch/action/admin/cluster/bootstrap/BootstrapClusterResponse.java

@@ -0,0 +1,66 @@
+/*
+ * 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.action.admin.cluster.bootstrap;
+
+import org.elasticsearch.action.ActionResponse;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+
+/**
+ * Response to a {@link BootstrapClusterRequest} indicating that the cluster has been successfully bootstrapped.
+ */
+public class BootstrapClusterResponse extends ActionResponse {
+    private final boolean alreadyBootstrapped;
+
+    public BootstrapClusterResponse(boolean alreadyBootstrapped) {
+        this.alreadyBootstrapped = alreadyBootstrapped;
+    }
+
+    public BootstrapClusterResponse(StreamInput in) throws IOException {
+        super(in);
+        alreadyBootstrapped = in.readBoolean();
+    }
+
+    /**
+     * @return whether this node already knew that the cluster had been bootstrapped when handling this request.
+     */
+    public boolean getAlreadyBootstrapped() {
+        return alreadyBootstrapped;
+    }
+
+    @Override
+    public void readFrom(StreamInput in) throws IOException {
+        throw new UnsupportedOperationException("usage of Streamable is to be replaced by Writeable");
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeBoolean(alreadyBootstrapped);
+    }
+
+    @Override
+    public String toString() {
+        return "BootstrapClusterResponse{" +
+            "alreadyBootstrapped=" + alreadyBootstrapped +
+            '}';
+    }
+}

server/src/main/java/org/elasticsearch/action/admin/cluster/bootstrap/BootstrapConfiguration.java

@@ -0,0 +1,179 @@
+/*
+ * 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.action.admin.cluster.bootstrap;
+
+import org.elasticsearch.ElasticsearchException;
+import org.elasticsearch.cluster.ClusterState.VotingConfiguration;
+import org.elasticsearch.cluster.node.DiscoveryNode;
+import org.elasticsearch.common.Nullable;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class BootstrapConfiguration implements Writeable {
+
+    private final List<NodeDescription> nodeDescriptions;
+
+    public BootstrapConfiguration(List<NodeDescription> nodeDescriptions) {
+        if (nodeDescriptions.isEmpty()) {
+            throw new IllegalArgumentException("cannot create empty bootstrap configuration");
+        }
+        this.nodeDescriptions = Collections.unmodifiableList(new ArrayList<>(nodeDescriptions));
+    }
+
+    public BootstrapConfiguration(StreamInput in) throws IOException {
+        nodeDescriptions = Collections.unmodifiableList(in.readList(NodeDescription::new));
+        assert nodeDescriptions.isEmpty() == false;
+    }
+
+    public List<NodeDescription> getNodeDescriptions() {
+        return nodeDescriptions;
+    }
+
+    public VotingConfiguration resolve(Iterable<DiscoveryNode> discoveredNodes) {
+        final Set<DiscoveryNode> selectedNodes = new HashSet<>();
+        for (final NodeDescription nodeDescription : nodeDescriptions) {
+            final DiscoveryNode discoveredNode = nodeDescription.resolve(discoveredNodes);
+            if (selectedNodes.add(discoveredNode) == false) {
+                throw new ElasticsearchException("multiple nodes matching {} in {}", discoveredNode, this);
+            }
+        }
+
+        final Set<String> nodeIds = selectedNodes.stream().map(DiscoveryNode::getId).collect(Collectors.toSet());
+        assert nodeIds.size() == selectedNodes.size() : selectedNodes + " does not contain distinct IDs";
+        return new VotingConfiguration(nodeIds);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeList(nodeDescriptions);
+    }
+
+    @Override
+    public String toString() {
+        return "BootstrapConfiguration{" +
+            "nodeDescriptions=" + nodeDescriptions +
+            '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        BootstrapConfiguration that = (BootstrapConfiguration) o;
+        return Objects.equals(nodeDescriptions, that.nodeDescriptions);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(nodeDescriptions);
+    }
+
+    public static class NodeDescription implements Writeable {
+
+        @Nullable
+        private final String id;
+
+        private final String name;
+
+        @Nullable
+        public String getId() {
+            return id;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public NodeDescription(@Nullable String id, String name) {
+            this.id = id;
+            this.name = Objects.requireNonNull(name);
+        }
+
+        public NodeDescription(DiscoveryNode discoveryNode) {
+            this(discoveryNode.getId(), discoveryNode.getName());
+        }
+
+        public NodeDescription(StreamInput in) throws IOException {
+            this(in.readOptionalString(), in.readString());
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeOptionalString(id);
+            out.writeString(name);
+        }
+
+        @Override
+        public String toString() {
+            return "NodeDescription{" +
+                "id='" + id + '\'' +
+                ", name='" + name + '\'' +
+                '}';
+        }
+
+        public DiscoveryNode resolve(Iterable<DiscoveryNode> discoveredNodes) {
+            DiscoveryNode selectedNode = null;
+            for (final DiscoveryNode discoveredNode : discoveredNodes) {
+                assert discoveredNode.isMasterNode() : discoveredNode;
+                if (discoveredNode.getName().equals(name)) {
+                    if (id == null || id.equals(discoveredNode.getId())) {
+                        if (selectedNode != null) {
+                            throw new ElasticsearchException(
+                                "discovered multiple nodes matching {} in {}", this, discoveredNodes);
+                        }
+                        selectedNode = discoveredNode;
+                    } else {
+                        throw new ElasticsearchException("node id mismatch comparing {} to {}", this, discoveredNode);
+                    }
+                } else if (id != null && id.equals(discoveredNode.getId())) {
+                    throw new ElasticsearchException("node name mismatch comparing {} to {}", this, discoveredNode);
+                }
+            }
+            if (selectedNode == null) {
+                throw new ElasticsearchException("no node matching {} found in {}", this, discoveredNodes);
+            }
+
+            return selectedNode;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            NodeDescription that = (NodeDescription) o;
+            return Objects.equals(id, that.id) &&
+                Objects.equals(name, that.name);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(id, name);
+        }
+    }
+}