import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
private static void assertTribeNodeSuccessfullyCreated(Settings extraSettings) throws Exception {
    //The tribe clients do need it to make sure they can find their corresponding tribes using the proper transport
    Settings settings = Settings.builder().put(NetworkModule.HTTP_ENABLED.getKey(), false).put("node.name", "tribe_node")
            .put("transport.type", MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME).put("discovery.type", "local")
            .put("tribe.t1.transport.type", MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME)
            .put("tribe.t2.transport.type",MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME)
            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir())
            .put(extraSettings).build();

    try (Node node = new MockNode(settings, Arrays.asList(MockTcpTransportPlugin.class, TestZenDiscovery.TestPlugin.class)).start()) {
        try (Client client = node.client()) {
            assertBusy(() -> {
                ClusterState state = client.admin().cluster().prepareState().clear().setNodes(true).get().getState();
                assertThat(state.getClusterName().value(), equalTo("tribe_node_cluster"));
                assertThat(state.getNodes().getSize(), equalTo(5));
                for (DiscoveryNode discoveryNode : state.getNodes()) {
                    assertThat(discoveryNode.getName(), either(equalTo("tribe1_node")).or(equalTo("tribe2_node"))
                            .or(equalTo("tribe_node")).or(equalTo("tribe_node/t1")).or(equalTo("tribe_node/t2")));
                }
            });
        }
    }
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
public Client createClient(Map<String, String> clientConfig) {
	Settings settings = Settings.builder().put(clientConfig)
		.put(NetworkModule.HTTP_TYPE_KEY, Netty3Plugin.NETTY_HTTP_TRANSPORT_NAME)
		.put(NetworkModule.TRANSPORT_TYPE_KEY, Netty3Plugin.NETTY_TRANSPORT_NAME)
		.build();

	TransportClient transportClient = new PreBuiltTransportClient(settings);
	for (TransportAddress transport : ElasticsearchUtils.convertInetSocketAddresses(transportAddresses)) {
		transportClient.addTransportAddress(transport);
	}

	// verify that we actually are connected to a cluster
	if (transportClient.connectedNodes().isEmpty()) {
		throw new RuntimeException("Elasticsearch client is not connected to any Elasticsearch nodes!");
	}

	if (LOG.isInfoEnabled()) {
		LOG.info("Created Elasticsearch TransportClient with connected nodes {}", transportClient.connectedNodes());
	}

	return transportClient;
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
public void testThatTransportClientCanConnect() throws Exception {
    Settings settings = Settings.builder()
        .put("cluster.name", internalCluster().getClusterName())
        .put(NetworkModule.TRANSPORT_TYPE_KEY, Netty4Plugin.NETTY_TRANSPORT_NAME)
        .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir().toString())
        .build();
    try (TransportClient transportClient = new MockTransportClient(settings, Netty4Plugin.class)) {
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), randomPort));
        ClusterHealthResponse response = transportClient.admin().cluster().prepareHealth().get();
        assertThat(response.getStatus(), is(ClusterHealthStatus.GREEN));
    }
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
/**
 * Lower the queue sizes to be small enough that both bulk and searches will time out and have to be retried.
 */
@Override
protected Settings nodeSettings() {
    Settings.Builder settings = Settings.builder().put(super.nodeSettings());
    // Use pools of size 1 so we can block them
    settings.put("thread_pool.bulk.size", 1);
    settings.put("thread_pool.search.size", 1);
    // Use queues of size 1 because size 0 is broken and because search requests need the queue to function
    settings.put("thread_pool.bulk.queue_size", 1);
    settings.put("thread_pool.search.queue_size", 1);
    // Enable http so we can test retries on reindex from remote. In this case the "remote" cluster is just this cluster.
    settings.put(NetworkModule.HTTP_ENABLED.getKey(), true);
    // Whitelist reindexing from the http host we're going to use
    settings.put(TransportReindexAction.REMOTE_CLUSTER_WHITELIST.getKey(), "127.0.0.1:*");
    return settings.build();
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Test
public void testPluginInstalled() {
    try (TransportClient client = new PreBuiltTransportClient(Settings.EMPTY)) {
        Settings settings = client.settings();
        assertEquals(Netty4Plugin.NETTY_TRANSPORT_NAME, NetworkModule.HTTP_DEFAULT_TYPE_SETTING.get(settings));
        assertEquals(Netty4Plugin.NETTY_TRANSPORT_NAME, NetworkModule.TRANSPORT_DEFAULT_TYPE_SETTING.get(settings));
    }
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
private static Client startClient(Path tempDir, TransportAddress... transportAddresses) {
    Settings.Builder builder = Settings.builder()
        .put("node.name", "qa_smoke_client_" + counter.getAndIncrement())
        .put("client.transport.ignore_cluster_name", true)
        .put(Environment.PATH_HOME_SETTING.getKey(), tempDir);
    final Collection<Class<? extends Plugin>> plugins;
    if (random().nextBoolean()) {
        builder.put(NetworkModule.TRANSPORT_TYPE_KEY, MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME);
        plugins = Collections.singleton(MockTcpTransportPlugin.class);
    } else {
        plugins = Collections.emptyList();
    }
    TransportClient client = new PreBuiltTransportClient(builder.build(), plugins).addTransportAddresses(transportAddresses);

    logger.info("--> Elasticsearch Java TransportClient started");

    Exception clientException = null;
    try {
        ClusterHealthResponse health = client.admin().cluster().prepareHealth().get();
        logger.info("--> connected to [{}] cluster which is running [{}] node(s).",
                health.getClusterName(), health.getNumberOfNodes());
    } catch (Exception e) {
        clientException = e;
    }

    assumeNoException("Sounds like your cluster is not running at " + clusterAddresses, clientException);

    return client;
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@BeforeClass
public static void createTribes() throws NodeValidationException {
    Settings baseSettings = Settings.builder()
        .put(NetworkModule.HTTP_ENABLED.getKey(), false)
        .put("transport.type", MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME)
        .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir())
        .put(NodeEnvironment.MAX_LOCAL_STORAGE_NODES_SETTING.getKey(), 2)
        .build();

    final List<Class<? extends Plugin>> mockPlugins = Arrays.asList(MockTcpTransportPlugin.class, TestZenDiscovery.TestPlugin.class);
    tribe1 = new MockNode(
        Settings.builder()
            .put(baseSettings)
            .put("cluster.name", "tribe1")
            .put("node.name", "tribe1_node")
                .put(NodeEnvironment.NODE_ID_SEED_SETTING.getKey(), random().nextLong())
            .build(), mockPlugins).start();
    tribe2 = new MockNode(
        Settings.builder()
            .put(baseSettings)
            .put("cluster.name", "tribe2")
            .put("node.name", "tribe2_node")
                .put(NodeEnvironment.NODE_ID_SEED_SETTING.getKey(), random().nextLong())
            .build(), mockPlugins).start();
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
public Settings nodeSettings(int nodeOrdinal) {
    Settings.Builder builder = Settings.builder().put(NodeEnvironment.MAX_LOCAL_STORAGE_NODES_SETTING.getKey(), numOfNodes);

    String[] unicastHosts = new String[unicastHostOrdinals.length];
    if (nodeOrdinal >= unicastHostPorts.length) {
        throw new ElasticsearchException("nodeOrdinal [" + nodeOrdinal + "] is greater than the number unicast ports [" + unicastHostPorts.length + "]");
    } else {
        // we need to pin the node port & host so we'd know where to point things
        builder.put(TransportSettings.PORT.getKey(), unicastHostPorts[nodeOrdinal]);
        builder.put(TransportSettings.HOST.getKey(), IP_ADDR); // only bind on one IF we use v4 here by default
        builder.put(NetworkModule.HTTP_ENABLED.getKey(), false);
        for (int i = 0; i < unicastHostOrdinals.length; i++) {
            unicastHosts[i] = IP_ADDR + ":" + (unicastHostPorts[unicastHostOrdinals[i]]);
        }
    }
    builder.putArray("discovery.zen.ping.unicast.hosts", unicastHosts);
    return builder.put(super.nodeSettings(nodeOrdinal)).build();
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
public void testNodeName() throws IOException {
    final Path tempDir = createTempDir();
    final String name = randomBoolean() ? randomAsciiOfLength(10) : null;
    Settings.Builder settings = Settings.builder()
        .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), InternalTestCluster.clusterName("single-node-cluster", randomLong()))
        .put(Environment.PATH_HOME_SETTING.getKey(), tempDir)
        .put(NetworkModule.HTTP_ENABLED.getKey(), false)
        .put("transport.type", "mock-socket-network")
        .put(Node.NODE_DATA_SETTING.getKey(), true);
    if (name != null) {
        settings.put(Node.NODE_NAME_SETTING.getKey(), name);
    }
    try (Node node = new MockNode(settings.build(), Collections.singleton(MockTcpTransportPlugin.class))) {
        final Settings nodeSettings = randomBoolean() ? node.settings() : node.getEnvironment().settings();
        if (name == null) {
            assertThat(Node.NODE_NAME_SETTING.get(nodeSettings), equalTo(node.getNodeEnvironment().nodeId().substring(0, 7)));
        } else {
            assertThat(Node.NODE_NAME_SETTING.get(nodeSettings), equalTo(name));
        }
    }
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
public void testMinimalSettings() {
    Settings globalSettings = Settings.builder()
        .put("node.name", "nodename")
        .put("path.home", "some/path").build();
    Settings clientSettings = TribeService.buildClientSettings("tribe1", "parent_id", globalSettings, Settings.EMPTY);
    assertEquals("some/path", clientSettings.get("path.home"));
    assertEquals("nodename/tribe1", clientSettings.get("node.name"));
    assertEquals("tribe1", clientSettings.get("tribe.name"));
    assertFalse(NetworkModule.HTTP_ENABLED.get(clientSettings));
    assertEquals("false", clientSettings.get("node.master"));
    assertEquals("false", clientSettings.get("node.data"));
    assertEquals("false", clientSettings.get("node.ingest"));
    assertEquals("false", clientSettings.get("node.local_storage"));
    assertEquals("3707202549613653169", clientSettings.get("node.id.seed")); // should be fixed by the parent id and tribe name
    assertEquals(9, clientSettings.size());
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
private Settings.Builder createTribeSettings(Predicate<InternalTestCluster> filter) {
    assertNotNull(filter);

    final Settings.Builder settings = Settings.builder();
    settings.put(Node.NODE_NAME_SETTING.getKey(), TRIBE_NODE);
    settings.put(Node.NODE_DATA_SETTING.getKey(), false);
    settings.put(Node.NODE_MASTER_SETTING.getKey(), true);
    settings.put(NetworkModule.HTTP_ENABLED.getKey(), false);
    settings.put(NetworkModule.TRANSPORT_TYPE_SETTING.getKey(), MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME);

    doWithAllClusters(filter, c -> {
        String tribeSetting = "tribe." + c.getClusterName() + ".";
        settings.put(tribeSetting + ClusterName.CLUSTER_NAME_SETTING.getKey(), c.getClusterName());
        settings.put(tribeSetting + DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.getKey(), "100ms");
        settings.put(tribeSetting + NetworkModule.TRANSPORT_TYPE_SETTING.getKey(), MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME);
    });

    return settings;
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
public void testSerializeRequest() throws IOException {
    ClusterRerouteRequest req = new ClusterRerouteRequest();
    req.setRetryFailed(randomBoolean());
    req.dryRun(randomBoolean());
    req.explain(randomBoolean());
    req.add(new AllocateEmptyPrimaryAllocationCommand("foo", 1, "bar", randomBoolean()));
    req.timeout(TimeValue.timeValueMillis(randomIntBetween(0, 100)));
    BytesStreamOutput out = new BytesStreamOutput();
    req.writeTo(out);
    BytesReference bytes = out.bytes();
    NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(NetworkModule.getNamedWriteables());
    StreamInput wrap = new NamedWriteableAwareStreamInput(bytes.streamInput(),
        namedWriteableRegistry);
    ClusterRerouteRequest deserializedReq = new ClusterRerouteRequest();
    deserializedReq.readFrom(wrap);

    assertEquals(req.isRetryFailed(), deserializedReq.isRetryFailed());
    assertEquals(req.dryRun(), deserializedReq.dryRun());
    assertEquals(req.explain(), deserializedReq.explain());
    assertEquals(req.timeout(), deserializedReq.timeout());
    assertEquals(1, deserializedReq.getCommands().commands().size()); // allocation commands have their own tests
    assertEquals(req.getCommands().commands().size(), deserializedReq.getCommands().commands().size());
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Bean(destroyMethod="close")
Node newNode() throws NodeValidationException {
  final Path tempDir = createTempDir().toPath();
  final Settings settings = Settings.builder()
    .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), new ClusterName("single-node-cluster" + System.nanoTime()))
    .put(Environment.PATH_HOME_SETTING.getKey(), tempDir)
    .put(Environment.PATH_REPO_SETTING.getKey(), tempDir.resolve("repo"))
    .put(Environment.PATH_SHARED_DATA_SETTING.getKey(), createTempDir().getParent())
    .put("node.name", "single-node")
    .put("script.inline", "true")
    .put("script.stored", "true")
    .put(ScriptService.SCRIPT_MAX_COMPILATIONS_PER_MINUTE.getKey(), 1000)
    .put(EsExecutors.PROCESSORS_SETTING.getKey(), 1)
    .put(NetworkModule.HTTP_ENABLED.getKey(), false)
    .put("discovery.type", "zen")
    .put("transport.type", "local")
    .put(Node.NODE_DATA_SETTING.getKey(), true)
    .put(NODE_ID_SEED_SETTING.getKey(), System.nanoTime())
    .build();
  return new Node(settings).start(); // NOSONAR
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
public void start(File tmpDataFolder, String clusterName) throws Exception {
	if (node == null) {
		Settings settings = Settings.builder()
			.put("cluster.name", clusterName)
			.put("http.enabled", false)
			.put("path.home", tmpDataFolder.getParent())
			.put("path.data", tmpDataFolder.getAbsolutePath())
			.put(NetworkModule.HTTP_TYPE_KEY, Netty3Plugin.NETTY_HTTP_TRANSPORT_NAME)
			.put(NetworkModule.TRANSPORT_TYPE_KEY, Netty3Plugin.NETTY_TRANSPORT_NAME)
			.build();

		node = new PluginNode(settings);
		node.start();
	}
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
public Settings additionalSettings() {
   final Settings.Builder builder = Settings.builder();
    
   if(!client && httpSSLEnabled) {
       
       if(settings.get("http.compression") == null) {
           builder.put("http.compression", false);
           log.info("Disabled https compression by default to mitigate BREACH attacks. You can enable it by setting 'http.compression: true' in elasticsearch.yml");
       }
       
       builder.put(NetworkModule.HTTP_TYPE_KEY, "com.floragunn.searchguard.ssl.http.netty.SearchGuardSSLNettyHttpServerTransport");
   }
    
   if (transportSSLEnabled) {
       builder.put(NetworkModule.TRANSPORT_TYPE_KEY, "com.floragunn.searchguard.ssl.http.netty.SearchGuardSSLNettyTransport");
   }
    
    return builder.build();
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
protected Client createClient() {
    StopWatch watch = new StopWatch();
    try {
        Settings.Builder settings = Settings.builder();
        settings.put(Environment.PATH_HOME_SETTING.getKey(), dataPath)
                .put(NetworkModule.HTTP_ENABLED.getKey(), false)
                .put(NetworkService.GLOBAL_NETWORK_BINDHOST_SETTING.getKey(), "_local_")
                .put(DiscoveryModule.DISCOVERY_TYPE_SETTING.getKey(), "single-node");
        MockNode node = new MockNode(settings.build());
        node.start();
        return node.client();
    } catch (NodeValidationException e) {
        throw new Error(e);
    } finally {
        logger.info("create local elasticsearch node, dataPath={}, elapsedTime={}", dataPath, watch.elapsedTime());
    }
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
public Settings additionalSettings() {
    return Settings.builder()
            // here we set the netty4 transport and http transport as the default. This is a set once setting
            // ie. if another plugin does that as well the server will fail - only one default network can exist!
            .put(NetworkModule.HTTP_DEFAULT_TYPE_SETTING.getKey(), NETTY_HTTP_TRANSPORT_NAME)
            .put(NetworkModule.TRANSPORT_DEFAULT_TYPE_SETTING.getKey(), NETTY_TRANSPORT_NAME)
            .build();
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
protected Settings nodeSettings(int nodeOrdinal) {
    Settings.Builder builder = Settings.builder().put(super.nodeSettings(nodeOrdinal));
    // randomize netty settings
    if (randomBoolean()) {
        builder.put(Netty4Transport.WORKER_COUNT.getKey(), random().nextInt(3) + 1);
    }
    builder.put(NetworkModule.TRANSPORT_TYPE_KEY, Netty4Plugin.NETTY_TRANSPORT_NAME);
    builder.put(NetworkModule.HTTP_TYPE_KEY, Netty4Plugin.NETTY_HTTP_TRANSPORT_NAME);
    return builder.build();
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
protected Settings nodeSettings(int nodeOrdinal) {
    return Settings.builder()
        .put(super.nodeSettings(nodeOrdinal))
        .put(NetworkModule.HTTP_ENABLED.getKey(), true)
        .put("http.pipelining", false)
        .build();
}
 

import org.elasticsearch.common.network.NetworkModule; //导入依赖的package包/类
@Override
protected Settings nodeSettings(int nodeOrdinal) {
    return Settings.builder()
        .put(super.nodeSettings(nodeOrdinal))
        .put(NetworkModule.HTTP_ENABLED.getKey(), true)
        .put("http.pipelining", true)
        .build();
}