Java DiscoveryNode.getId方法代码示例

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
protected void onNodeFailure(DiscoveryNode node, int nodeIndex, Throwable t) {
    String nodeId = node.getId();
    if (logger.isDebugEnabled() && !(t instanceof NodeShouldNotConnectException)) {
        logger.debug(
            (org.apache.logging.log4j.util.Supplier<?>)
                () -> new ParameterizedMessage("failed to execute [{}] on node [{}]", actionName, nodeId), t);
    }

    // this is defensive to protect against the possibility of double invocation
    // the current implementation of TransportService#sendRequest guards against this
    // but concurrency is hard, safety is important, and the small performance loss here does not matter
    if (responses.compareAndSet(nodeIndex, null, new FailedNodeException(nodeId, "Failed node [" + nodeId + "]", t))) {
        if (counter.incrementAndGet() == responses.length()) {
            onCompletion();
        }
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
@Before
public void setupForTest() {
    // Fill the context with something random so we can make sure we inherited it appropriately.
    expectedHeaders.clear();
    expectedHeaders.put(randomSimpleString(random()), randomSimpleString(random()));

    setupClient(new TestThreadPool(getTestName()));
    firstSearchRequest = new SearchRequest();
    testRequest = new DummyAbstractBulkByScrollRequest(firstSearchRequest);
    listener = new PlainActionFuture<>();
    scrollId = null;
    taskManager = new TaskManager(Settings.EMPTY);
    testTask = (WorkingBulkByScrollTask) taskManager.register("don'tcare", "hereeither", testRequest);

    localNode = new DiscoveryNode("thenode", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
    taskId = new TaskId(localNode.getId(), testTask.getId());
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
private void sendNodeRequest(final DiscoveryNode node, List<ShardRouting> shards, final int nodeIndex) {
    try {
        NodeRequest nodeRequest = new NodeRequest(node.getId(), request, shards);
        if (task != null) {
            nodeRequest.setParentTask(clusterService.localNode().getId(), task.getId());
        }
        transportService.sendRequest(node, transportNodeBroadcastAction, nodeRequest, new TransportResponseHandler<NodeResponse>() {
            @Override
            public NodeResponse newInstance() {
                return new NodeResponse();
            }

            @Override
            public void handleResponse(NodeResponse response) {
                onNodeResponse(node, nodeIndex, response);
            }

            @Override
            public void handleException(TransportException exp) {
                onNodeFailure(node, nodeIndex, exp);
            }

            @Override
            public String executor() {
                return ThreadPool.Names.SAME;
            }
        });
    } catch (Exception e) {
        onNodeFailure(node, nodeIndex, e);
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public void testRejectingJoinWithSameIdButDifferentNode() throws InterruptedException, ExecutionException {
    addNodes(randomInt(5));
    ClusterState state = clusterService.state();
    final DiscoveryNode existing = randomFrom(StreamSupport.stream(state.nodes().spliterator(), false).collect(Collectors.toList()));
    final DiscoveryNode other_node = new DiscoveryNode(
        randomBoolean() ? existing.getName() : "other_name",
        existing.getId(),
        randomBoolean() ? existing.getAddress() : buildNewFakeTransportAddress(),
        randomBoolean() ? existing.getAttributes() : Collections.singletonMap("attr", "other"),
        randomBoolean() ? existing.getRoles() : new HashSet<>(randomSubsetOf(Arrays.asList(DiscoveryNode.Role.values()))),
        randomBoolean() ? existing.getVersion() : VersionUtils.randomVersion(random()));

    ExecutionException e = expectThrows(ExecutionException.class, () -> joinNode(other_node));
    assertThat(e.getMessage(), containsString("found existing node"));
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public void testRejectingRestartedNodeJoinsBeforeProcessingNodeLeft() throws InterruptedException, ExecutionException {
    addNodes(randomInt(5));
    ClusterState state = clusterService.state();
    final DiscoveryNode existing = randomFrom(StreamSupport.stream(state.nodes().spliterator(), false).collect(Collectors.toList()));
    joinNode(existing); // OK

    final DiscoveryNode other_node = new DiscoveryNode(existing.getId(), existing.getAddress(), existing.getAttributes(),
        existing.getRoles(), Version.CURRENT);

    ExecutionException e = expectThrows(ExecutionException.class, () -> joinNode(other_node));
    assertThat(e.getMessage(), containsString("found existing node"));
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
private <T extends TransportResponse> TransportResponseHandler wrapLivenessResponseHandler(TransportResponseHandler<T> handler,
                                                                                           DiscoveryNode node,
                                                                                           ClusterName clusterName) {
    return new TransportResponseHandler<T>() {
        @Override
        public T newInstance() {
            return handler.newInstance();
        }

        @Override
        @SuppressWarnings("unchecked")
        public void handleResponse(T response) {
            LivenessResponse livenessResponse = new LivenessResponse(clusterName,
                    new DiscoveryNode(node.getName(), node.getId(), node.getEphemeralId(), "liveness-hostname" + node.getId(),
                            "liveness-hostaddress" + node.getId(),
                            livenessAddress, node.getAttributes(), node.getRoles(),
                            node.getVersion()));
            handler.handleResponse((T)livenessResponse);
        }

        @Override
        public void handleException(TransportException exp) {
            handler.handleException(exp);
        }

        @Override
        public String executor() {
            return handler.executor();
        }
    };
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
/**
 * Registers recording task event listeners with the given action mask on all nodes
 */
private void registerTaskManageListeners(String actionMasks) {
    for (String nodeName : internalCluster().getNodeNames()) {
        DiscoveryNode node = internalCluster().getInstance(ClusterService.class, nodeName).localNode();
        RecordingTaskManagerListener listener = new RecordingTaskManagerListener(node.getId(), actionMasks.split(","));
        ((MockTaskManager) internalCluster().getInstance(TransportService.class, nodeName).getTaskManager()).addListener(listener);
        RecordingTaskManagerListener oldListener = listeners.put(new Tuple<>(node.getName(), actionMasks), listener);
        assertNull(oldListener);
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public TaskInfo(DiscoveryNode node, long id, String type, String action, String description, Task.Status status, long startTime,
                long runningTimeNanos, TaskId parentTaskId) {
    this.node = node;
    this.taskId = new TaskId(node.getId(), id);
    this.type = type;
    this.action = action;
    this.description = description;
    this.status = status;
    this.startTime = startTime;
    this.runningTimeNanos = runningTimeNanos;
    this.parentTaskId = parentTaskId;
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
private void sendNodeRequest(final DiscoveryNode node, List<ShardRouting> shards, final int nodeIndex) {
    try {
        NodeRequest nodeRequest = new NodeRequest(node.getId(), request, shards);
        if (task != null) {
            nodeRequest.setParentTask(clusterService.localNode().id(), task.getId());
            taskManager.registerChildTask(task, node.getId());
        }
        transportService.sendRequest(node, transportNodeBroadcastAction, nodeRequest, new BaseTransportResponseHandler<NodeResponse>() {
            @Override
            public NodeResponse newInstance() {
                return new NodeResponse();
            }

            @Override
            public void handleResponse(NodeResponse response) {
                onNodeResponse(node, nodeIndex, response);
            }

            @Override
            public void handleException(TransportException exp) {
                onNodeFailure(node, nodeIndex, exp);
            }

            @Override
            public String executor() {
                return ThreadPool.Names.SAME;
            }
        });
    } catch (Throwable e) {
        onNodeFailure(node, nodeIndex, e);
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
/**
 * Convenience constructor for building the TaskId out of what is usually at hand.
 */
public ParentTaskAssigningClient(Client in, DiscoveryNode localNode, Task parentTask) {
    this(in, new TaskId(localNode.getId(), parentTask.getId()));
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
void start() {
    final DiscoveryNode[] nodes = request.concreteNodes();
    if (nodes.length == 0) {
        // nothing to notify
        threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
        return;
    }
    TransportRequestOptions.Builder builder = TransportRequestOptions.builder();
    if (request.timeout() != null) {
        builder.withTimeout(request.timeout());
    }
    builder.withCompress(transportCompress());
    for (int i = 0; i < nodes.length; i++) {
        final int idx = i;
        final DiscoveryNode node = nodes[i];
        final String nodeId = node.getId();
        try {
            if (node == null) {
                onFailure(idx, nodeId, new NoSuchNodeException(nodeId));
            } else {
                TransportRequest nodeRequest = newNodeRequest(nodeId, request);
                if (task != null) {
                    nodeRequest.setParentTask(clusterService.localNode().getId(), task.getId());
                }

                transportService.sendRequest(node, transportNodeAction, nodeRequest, builder.build(),
                                             new TransportResponseHandler<NodeResponse>() {
                    @Override
                    public NodeResponse newInstance() {
                        return newNodeResponse();
                    }

                    @Override
                    public void handleResponse(NodeResponse response) {
                        onOperation(idx, response);
                    }

                    @Override
                    public void handleException(TransportException exp) {
                        onFailure(idx, node.getId(), exp);
                    }

                    @Override
                    public String executor() {
                        return ThreadPool.Names.SAME;
                    }
                });
            }
        } catch (Exception e) {
            onFailure(idx, nodeId, e);
        }
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
/**
 * creates an object clone of node, so it will be a different object instance
 */
private DiscoveryNode cloneNode(DiscoveryNode node) {
    return new DiscoveryNode(node.getName(), node.getId(), node.getEphemeralId(), node.getHostName(), node.getHostAddress(),
        node.getAddress(), node.getAttributes(), node.getRoles(), node.getVersion());
}