Java NetworkUtils.SUPPORTS_V6属性代码示例

public void testHttpPublishPort() throws Exception {
    int boundPort = randomIntBetween(9000, 9100);
    int otherBoundPort = randomIntBetween(9200, 9300);

    int publishPort = resolvePublishPort(Settings.builder().put(HttpTransportSettings.SETTING_HTTP_PUBLISH_PORT.getKey(), 9080).build(),
        randomAddresses(), getByName("127.0.0.2"));
    assertThat("Publish port should be explicitly set to 9080", publishPort, equalTo(9080));

    publishPort = resolvePublishPort(Settings.EMPTY, asList(address("127.0.0.1", boundPort), address("127.0.0.2", otherBoundPort)),
        getByName("127.0.0.1"));
    assertThat("Publish port should be derived from matched address", publishPort, equalTo(boundPort));

    publishPort = resolvePublishPort(Settings.EMPTY, asList(address("127.0.0.1", boundPort), address("127.0.0.2", boundPort)),
        getByName("127.0.0.3"));
    assertThat("Publish port should be derived from unique port of bound addresses", publishPort, equalTo(boundPort));

    final BindHttpException e =
        expectThrows(BindHttpException.class,
            () -> resolvePublishPort(
                Settings.EMPTY,
                asList(address("127.0.0.1", boundPort), address("127.0.0.2", otherBoundPort)),
                getByName("127.0.0.3")));
    assertThat(e.getMessage(), containsString("Failed to auto-resolve http publish port"));

    publishPort = resolvePublishPort(Settings.EMPTY, asList(address("0.0.0.0", boundPort), address("127.0.0.2", otherBoundPort)),
        getByName("127.0.0.1"));
    assertThat("Publish port should be derived from matching wildcard address", publishPort, equalTo(boundPort));

    if (NetworkUtils.SUPPORTS_V6) {
        publishPort = resolvePublishPort(Settings.EMPTY, asList(address("0.0.0.0", boundPort), address("127.0.0.2", otherBoundPort)),
            getByName("::1"));
        assertThat("Publish port should be derived from matching wildcard address", publishPort, equalTo(boundPort));
    }
}
 

@Before
public void setup() {
    if (NetworkUtils.SUPPORTS_V6 && randomBoolean()) {
        host = "::1";
    } else {
        host = "127.0.0.1";
    }
}
 

public void testDifferentPorts() throws Exception {
    if (!NetworkUtils.SUPPORTS_V6) {
        return;
    }
    logger.info("--> starting a node on ipv4 only");
    Settings ipv4Settings = Settings.builder().put("network.host", "127.0.0.1").build();
    String ipv4OnlyNode = internalCluster().startNode(ipv4Settings); // should bind 127.0.0.1:XYZ

    logger.info("--> starting a node on ipv4 and ipv6");
    Settings bothSettings = Settings.builder().put("network.host", "_local_").build();
    internalCluster().startNode(bothSettings); // should bind [::1]:XYZ and 127.0.0.1:XYZ+1

    logger.info("--> waiting for the cluster to declare itself stable");
    ensureStableCluster(2); // fails if port of publish address does not match corresponding bound address

    logger.info("--> checking if boundAddress matching publishAddress has same port");
    NodesInfoResponse nodesInfoResponse = client().admin().cluster().prepareNodesInfo().get();
    for (NodeInfo nodeInfo : nodesInfoResponse.getNodes()) {
        BoundTransportAddress boundTransportAddress = nodeInfo.getTransport().getAddress();
        if (nodeInfo.getNode().getName().equals(ipv4OnlyNode)) {
            assertThat(boundTransportAddress.boundAddresses().length, equalTo(1));
            assertThat(boundTransportAddress.boundAddresses()[0].getPort(), equalTo(boundTransportAddress.publishAddress().getPort()));
        } else {
            assertThat(boundTransportAddress.boundAddresses().length, greaterThan(1));
            for (TransportAddress boundAddress : boundTransportAddress.boundAddresses()) {
                assertThat(boundAddress, instanceOf(TransportAddress.class));
                TransportAddress inetBoundAddress = (TransportAddress) boundAddress;
                if (inetBoundAddress.address().getAddress() instanceof Inet4Address) {
                    // IPv4 address is preferred publish address for _local_
                    assertThat(inetBoundAddress.getPort(), equalTo(boundTransportAddress.publishAddress().getPort()));
                }
            }
        }
    }
}
 

@Override
public List<String> getLocalAddresses() {
    List<String> local = new ArrayList<>();
    local.add("127.0.0.1");
    // check if v6 is supported, if so, v4 will also work via mapped addresses.
    if (NetworkUtils.SUPPORTS_V6) {
        local.add("[::1]"); // may get ports appended!
    }
    return local;
}
 

public void testPublishPort() throws Exception {
    int boundPort = randomIntBetween(9000, 9100);
    int otherBoundPort = randomIntBetween(9200, 9300);

    boolean useProfile = randomBoolean();
    final String profile;
    final Settings settings;
    final Settings profileSettings;
    if (useProfile) {
        profile = "some_profile";
        settings = randomBoolean() ? Settings.EMPTY : Settings.builder().put(TransportSettings.PUBLISH_PORT.getKey(), 9081).build();
        profileSettings = Settings.builder().put("publish_port", 9080).build();
    } else {
        profile = TransportSettings.DEFAULT_PROFILE;
        settings = Settings.builder().put(TransportSettings.PUBLISH_PORT.getKey(), 9081).build();
        profileSettings = randomBoolean() ? Settings.EMPTY : Settings.builder().put("publish_port", 9080).build();;
    }

    int publishPort = resolvePublishPort(profile, settings, profileSettings,
        randomAddresses(), getByName("127.0.0.2"));
    assertThat("Publish port should be explicitly set", publishPort, equalTo(useProfile ? 9080 : 9081));

    publishPort = resolvePublishPort(profile, Settings.EMPTY, Settings.EMPTY,
        asList(address("127.0.0.1", boundPort), address("127.0.0.2", otherBoundPort)),
        getByName("127.0.0.1"));
    assertThat("Publish port should be derived from matched address", publishPort, equalTo(boundPort));

    publishPort = resolvePublishPort(profile, Settings.EMPTY, Settings.EMPTY,
        asList(address("127.0.0.1", boundPort), address("127.0.0.2", boundPort)),
        getByName("127.0.0.3"));
    assertThat("Publish port should be derived from unique port of bound addresses", publishPort, equalTo(boundPort));

    try {
        resolvePublishPort(profile, Settings.EMPTY, Settings.EMPTY,
            asList(address("127.0.0.1", boundPort), address("127.0.0.2", otherBoundPort)),
            getByName("127.0.0.3"));
        fail("Expected BindTransportException as publish_port not specified and non-unique port of bound addresses");
    } catch (BindTransportException e) {
        assertThat(e.getMessage(), containsString("Failed to auto-resolve publish port"));
    }

    publishPort = resolvePublishPort(profile, Settings.EMPTY, Settings.EMPTY,
        asList(address("0.0.0.0", boundPort), address("127.0.0.2", otherBoundPort)),
        getByName("127.0.0.1"));
    assertThat("Publish port should be derived from matching wildcard address", publishPort, equalTo(boundPort));

    if (NetworkUtils.SUPPORTS_V6) {
        publishPort = resolvePublishPort(profile, Settings.EMPTY, Settings.EMPTY,
            asList(address("0.0.0.0", boundPort), address("127.0.0.2", otherBoundPort)),
            getByName("::1"));
        assertThat("Publish port should be derived from matching wildcard address", publishPort, equalTo(boundPort));
    }
}