Java Version.min方法代碼示例

import org.elasticsearch.Version; //導入方法依賴的package包/類
public DiscoveryNodes build() {
    ImmutableOpenMap.Builder<String, DiscoveryNode> dataNodesBuilder = ImmutableOpenMap.builder();
    ImmutableOpenMap.Builder<String, DiscoveryNode> masterNodesBuilder = ImmutableOpenMap.builder();
    ImmutableOpenMap.Builder<String, DiscoveryNode> ingestNodesBuilder = ImmutableOpenMap.builder();
    Version minNodeVersion = Version.CURRENT;
    Version maxNodeVersion = Version.CURRENT;
    Version minNonClientNodeVersion = Version.CURRENT;
    for (ObjectObjectCursor<String, DiscoveryNode> nodeEntry : nodes) {
        if (nodeEntry.value.isDataNode()) {
            dataNodesBuilder.put(nodeEntry.key, nodeEntry.value);
            minNonClientNodeVersion = Version.min(minNonClientNodeVersion, nodeEntry.value.getVersion());
        }
        if (nodeEntry.value.isMasterNode()) {
            masterNodesBuilder.put(nodeEntry.key, nodeEntry.value);
            minNonClientNodeVersion = Version.min(minNonClientNodeVersion, nodeEntry.value.getVersion());
        }
        if (nodeEntry.value.isIngestNode()) {
            ingestNodesBuilder.put(nodeEntry.key, nodeEntry.value);
        }
        minNodeVersion = Version.min(minNodeVersion, nodeEntry.value.getVersion());
        maxNodeVersion = Version.max(maxNodeVersion, nodeEntry.value.getVersion());
    }

    return new DiscoveryNodes(
        nodes.build(), dataNodesBuilder.build(), masterNodesBuilder.build(), ingestNodesBuilder.build(),
        masterNodeId, localNodeId, minNonClientNodeVersion, maxNodeVersion, minNodeVersion
    );
}
 

import org.elasticsearch.Version; //導入方法依賴的package包/類
private void sendRequestToChannel(DiscoveryNode node, final Channel targetChannel, final long requestId, final String action,
                                    final TransportRequest request, TransportRequestOptions options, Version channelVersion,
                                  byte status) throws IOException,
    TransportException {
    if (compress) {
        options = TransportRequestOptions.builder(options).withCompress(true).build();
    }
    status = TransportStatus.setRequest(status);
    ReleasableBytesStreamOutput bStream = new ReleasableBytesStreamOutput(bigArrays);
    // we wrap this in a release once since if the onRequestSent callback throws an exception
    // we might release things twice and this should be prevented
    final Releasable toRelease = Releasables.releaseOnce(() -> Releasables.close(bStream.bytes()));
    boolean addedReleaseListener = false;
    StreamOutput stream = bStream;
    try {
        // only compress if asked, and, the request is not bytes, since then only
        // the header part is compressed, and the "body" can't be extracted as compressed
        if (options.compress() && canCompress(request)) {
            status = TransportStatus.setCompress(status);
            stream = CompressorFactory.COMPRESSOR.streamOutput(stream);
        }

        // we pick the smallest of the 2, to support both backward and forward compatibility
        // note, this is the only place we need to do this, since from here on, we use the serialized version
        // as the version to use also when the node receiving this request will send the response with
        Version version = Version.min(getCurrentVersion(), channelVersion);

        stream.setVersion(version);
        threadPool.getThreadContext().writeTo(stream);
        stream.writeString(action);
        BytesReference message = buildMessage(requestId, status, node.getVersion(), request, stream, bStream);
        final TransportRequestOptions finalOptions = options;
        Runnable onRequestSent = () -> { // this might be called in a different thread
            try {
                toRelease.close();
            } finally {
                transportServiceAdapter.onRequestSent(node, requestId, action, request, finalOptions);
            }
        };
        addedReleaseListener = internalSendMessage(targetChannel, message, onRequestSent);
    } finally {
        IOUtils.close(stream);
        if (!addedReleaseListener) {
            toRelease.close();
        }
    }
}