Java ClusterStateAction类代码示例

import org.elasticsearch.action.admin.cluster.state.ClusterStateAction; //导入依赖的package包/类
protected boolean connect(Collection<InetSocketTransportAddress> addresses, boolean autodiscover) {
    logger.info("trying to connect to {}", addresses);
    client.addTransportAddresses(addresses);
    if (client.connectedNodes() != null) {
        List<DiscoveryNode> nodes = client.connectedNodes();
        if (!nodes.isEmpty()) {
            logger.info("connected to {}", nodes);
            if (autodiscover) {
                logger.info("trying to auto-discover all cluster nodes...");
                ClusterStateRequestBuilder clusterStateRequestBuilder =
                        new ClusterStateRequestBuilder(client, ClusterStateAction.INSTANCE);
                ClusterStateResponse clusterStateResponse = clusterStateRequestBuilder.execute().actionGet();
                DiscoveryNodes discoveryNodes = clusterStateResponse.getState().getNodes();
                client.addDiscoveryNodes(discoveryNodes);
                logger.info("after auto-discovery connected to {}", client.connectedNodes());
            }
            return true;
        }
        return false;
    }
    return false;
}
 

import org.elasticsearch.action.admin.cluster.state.ClusterStateAction; //导入依赖的package包/类
@Override
public AsyncSender interceptSender(AsyncSender sender) {
    return new AsyncSender() {
        @Override
        public <T extends TransportResponse> void sendRequest(Transport.Connection connection, String action,
                                                              TransportRequest request,
                                                              TransportRequestOptions options,
                                                              TransportResponseHandler<T> handler) {
            final ClusterName clusterName = new ClusterName("cluster1");
            if (TransportLivenessAction.NAME.equals(action)) {
                assertHeaders(threadPool);
                ((TransportResponseHandler<LivenessResponse>) handler).handleResponse(
                    new LivenessResponse(clusterName, connection.getNode()));
            } else if (ClusterStateAction.NAME.equals(action)) {
                assertHeaders(threadPool);
                ClusterName cluster1 = clusterName;
                ClusterState.Builder builder = ClusterState.builder(cluster1);
                //the sniffer detects only data nodes
                builder.nodes(DiscoveryNodes.builder().add(new DiscoveryNode("node_id", "someId", "some_ephemeralId_id",
                    address.address().getHostString(), address.getAddress(), address, Collections.emptyMap(),
                        Collections.singleton(DiscoveryNode.Role.DATA), Version.CURRENT)));
                ((TransportResponseHandler<ClusterStateResponse>) handler)
                        .handleResponse(new ClusterStateResponse(cluster1, builder.build(), 0L));
                clusterStateLatch.countDown();
            } else if (TransportService.HANDSHAKE_ACTION_NAME .equals(action)) {
                ((TransportResponseHandler<TransportService.HandshakeResponse>) handler).handleResponse(
                    new TransportService.HandshakeResponse(connection.getNode(), clusterName, connection.getNode().getVersion()));
            } else {
                handler.handleException(new TransportException("", new InternalException(action)));
            }
        }
    };
}
 

import org.elasticsearch.action.admin.cluster.state.ClusterStateAction; //导入依赖的package包/类
public static MockTransportService startTransport(String id, List<DiscoveryNode> knownNodes, Version version, ThreadPool threadPool) {
    boolean success = false;
    MockTransportService newService = MockTransportService.createNewService(Settings.EMPTY, version, threadPool, null);
    try {
        newService.registerRequestHandler(ClusterSearchShardsAction.NAME, ClusterSearchShardsRequest::new, ThreadPool.Names.SAME,
            (request, channel) -> {
                channel.sendResponse(new ClusterSearchShardsResponse(new ClusterSearchShardsGroup[0],
                    knownNodes.toArray(new DiscoveryNode[0]), Collections.emptyMap()));
            });
        newService.registerRequestHandler(ClusterStateAction.NAME, ClusterStateRequest::new, ThreadPool.Names.SAME,
            (request, channel) -> {
                DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
                for (DiscoveryNode node : knownNodes) {
                    builder.add(node);
                }
                ClusterState build = ClusterState.builder(ClusterName.DEFAULT).nodes(builder.build()).build();
                channel.sendResponse(new ClusterStateResponse(ClusterName.DEFAULT, build, 0L));
            });
        newService.start();
        newService.acceptIncomingRequests();
        success = true;
        return newService;
    } finally {
        if (success == false) {
            newService.close();
        }
    }
}
 

import org.elasticsearch.action.admin.cluster.state.ClusterStateAction; //导入依赖的package包/类
@Override
public ActionFuture<ClusterStateResponse> state(final ClusterStateRequest request) {
    return execute(ClusterStateAction.INSTANCE, request);
}
 

import org.elasticsearch.action.admin.cluster.state.ClusterStateAction; //导入依赖的package包/类
@Override
public ClusterStateRequestBuilder prepareState() {
    return new ClusterStateRequestBuilder(this, ClusterStateAction.INSTANCE);
}
 

import org.elasticsearch.action.admin.cluster.state.ClusterStateAction; //导入依赖的package包/类
public ClusterStateAction getAction() {
    return ClusterStateAction.INSTANCE;
}