private int[] getRandomPorts(int numberOfPorts) {
IntHashSet ports = new IntHashSet();
int nextPort = randomIntBetween(49152, 65535);
for (int i = 0; i < numberOfPorts; i++) {
boolean foundPortInRange = false;
while (!foundPortInRange) {
if (!ports.contains(nextPort)) {
logger.debug("looking to see if port [{}]is available", nextPort);
try (ServerSocket serverSocket = new ServerSocket()) {
// Set SO_REUSEADDR as we may bind here and not be able
// to reuse the address immediately without it.
serverSocket.setReuseAddress(NetworkUtils.defaultReuseAddress());
serverSocket.bind(new InetSocketAddress(nextPort));
// bind was a success
logger.debug("port [{}] available.", nextPort);
foundPortInRange = true;
ports.add(nextPort);
} catch (IOException e) {
// Do nothing
logger.debug("port [{}] not available.", e, nextPort);
}
}
nextPort = randomIntBetween(49152, 65535);
}
}
return ports.toArray();
}
@Test
public void testThatBindingOnDifferentHostsWorks() throws Exception {
int[] ports = getRandomPorts(2);
InetAddress firstNonLoopbackAddress =
NetworkUtils.getFirstNonLoopbackAddress(NetworkUtils.StackType.IPv4);
assumeTrue(
"No IP-v4 non-loopback address available - are you on a plane?",
firstNonLoopbackAddress != null);
Settings settings =
settingsBuilder()
.put("network.host", "127.0.0.1")
.put("transport.tcp.port", ports[0])
.put("transport.profiles.default.bind_host", "127.0.0.1")
.put("transport.profiles.client1.bind_host", firstNonLoopbackAddress.getHostAddress())
.put("transport.profiles.client1.port", ports[1])
.build();
ThreadPool threadPool = new ThreadPool("tst");
try (NettyTransport ignored = startNettyTransport(settings, threadPool)) {
assertPortIsBound("127.0.0.1", ports[0]);
assertPortIsBound(firstNonLoopbackAddress.getHostAddress(), ports[1]);
assertConnectionRefused(ports[1]);
} finally {
terminate(threadPool);
}
}
public static String clusterName(String prefix, String childVMId, long clusterSeed) {
StringBuilder builder = new StringBuilder(prefix);
builder.append('-').append(NetworkUtils.getLocalAddress().getHostName());
builder.append("-CHILD_VM=[").append(childVMId).append(']');
builder.append("-CLUSTER_SEED=[").append(clusterSeed).append(']');
// if multiple maven task run on a single host we better have an identifier that doesn't rely on
// input params
builder.append("-HASH=[").append(SeedUtils.formatSeed(System.nanoTime())).append(']');
return builder.toString();
}
@BeforeMethod
public void setup() throws IOException, TTransportException {
node =
nodeBuilder()
.settings(
settingsBuilder()
.put("cluster.name", "test-cluster-" + NetworkUtils.getLocalAddress())
.put("gateway.type", "none"))
.node();
transport = new TSocket("localhost", 9500);
TProtocol protocol = new TBinaryProtocol(transport);
client = new Rest.Client(protocol);
transport.open();
}
@SuppressForbidden(reason = "we know we pass a IP address")
protected static synchronized int[] unicastHostPorts(int numHosts) {
int[] unicastHostPorts = new int[numHosts];
final int basePort = calcBasePort();
final int maxPort = basePort + InternalTestCluster.PORTS_PER_JVM;
int tries = 0;
for (int i = 0; i < unicastHostPorts.length; i++) {
boolean foundPortInRange = false;
while (tries < InternalTestCluster.PORTS_PER_JVM && !foundPortInRange) {
try (ServerSocket serverSocket = new ServerSocket()) {
// Set SO_REUSEADDR as we may bind here and not be able to reuse the address immediately
// without it.
serverSocket.setReuseAddress(NetworkUtils.defaultReuseAddress());
serverSocket.bind(new InetSocketAddress(IP_ADDR, nextPort));
// bind was a success
foundPortInRange = true;
unicastHostPorts[i] = nextPort;
} catch (IOException e) {
// Do nothing
}
nextPort++;
if (nextPort >= maxPort) {
// Roll back to the beginning of the range and do not go into another JVM's port range
nextPort = basePort;
}
tries++;
}
if (!foundPortInRange) {
throw new ElasticsearchException(
"could not find enough open ports in range ["
+ basePort
+ "-"
+ maxPort
+ "]. required ["
+ unicastHostPorts.length
+ "] ports");
}
}
return unicastHostPorts;
}
@Inject
public NettyHttpServerTransport(
Settings settings, NetworkService networkService, BigArrays bigArrays) {
super(settings);
this.networkService = networkService;
this.bigArrays = bigArrays;
if (settings.getAsBoolean("netty.epollBugWorkaround", false)) {
System.setProperty("org.jboss.netty.epollBugWorkaround", "true");
}
ByteSizeValue maxContentLength =
settings.getAsBytesSize(
"http.netty.max_content_length",
settings.getAsBytesSize(
"http.max_content_length", new ByteSizeValue(100, ByteSizeUnit.MB)));
this.maxChunkSize =
settings.getAsBytesSize(
"http.netty.max_chunk_size",
settings.getAsBytesSize("http.max_chunk_size", new ByteSizeValue(8, ByteSizeUnit.KB)));
this.maxHeaderSize =
settings.getAsBytesSize(
"http.netty.max_header_size",
settings.getAsBytesSize("http.max_header_size", new ByteSizeValue(8, ByteSizeUnit.KB)));
this.maxInitialLineLength =
settings.getAsBytesSize(
"http.netty.max_initial_line_length",
settings.getAsBytesSize(
"http.max_initial_line_length", new ByteSizeValue(4, ByteSizeUnit.KB)));
// don't reset cookies by default, since I don't think we really need to
// note, parsing cookies was fixed in netty 3.5.1 regarding stack allocation, but still,
// currently, we don't need cookies
this.resetCookies =
settings.getAsBoolean(
"http.netty.reset_cookies", settings.getAsBoolean("http.reset_cookies", false));
this.maxCumulationBufferCapacity =
settings.getAsBytesSize("http.netty.max_cumulation_buffer_capacity", null);
this.maxCompositeBufferComponents =
settings.getAsInt("http.netty.max_composite_buffer_components", -1);
this.workerCount =
settings.getAsInt(
"http.netty.worker_count", EsExecutors.boundedNumberOfProcessors(settings) * 2);
this.blockingServer =
settings.getAsBoolean(
"http.netty.http.blocking_server",
settings.getAsBoolean(TCP_BLOCKING_SERVER, settings.getAsBoolean(TCP_BLOCKING, false)));
this.port = settings.get("http.netty.port", settings.get("http.port", "9200-9300"));
this.bindHost =
settings.get(
"http.netty.bind_host", settings.get("http.bind_host", settings.get("http.host")));
this.publishHost =
settings.get(
"http.netty.publish_host",
settings.get("http.publish_host", settings.get("http.host")));
this.publishPort =
settings.getAsInt("http.netty.publish_port", settings.getAsInt("http.publish_port", 0));
this.tcpNoDelay = settings.get("http.netty.tcp_no_delay", settings.get(TCP_NO_DELAY, "true"));
this.tcpKeepAlive =
settings.get("http.netty.tcp_keep_alive", settings.get(TCP_KEEP_ALIVE, "true"));
this.reuseAddress =
settings.getAsBoolean(
"http.netty.reuse_address",
settings.getAsBoolean(TCP_REUSE_ADDRESS, NetworkUtils.defaultReuseAddress()));
this.tcpSendBufferSize =
settings.getAsBytesSize(
"http.netty.tcp_send_buffer_size",
settings.getAsBytesSize(TCP_SEND_BUFFER_SIZE, TCP_DEFAULT_SEND_BUFFER_SIZE));
this.tcpReceiveBufferSize =
settings.getAsBytesSize(
"http.netty.tcp_receive_buffer_size",
settings.getAsBytesSize(TCP_RECEIVE_BUFFER_SIZE, TCP_DEFAULT_RECEIVE_BUFFER_SIZE));
this.detailedErrorsEnabled = settings.getAsBoolean(SETTING_HTTP_DETAILED_ERRORS_ENABLED, true);
long defaultReceiverPredictor = 512 * 1024;
if (JvmInfo.jvmInfo().getMem().getDirectMemoryMax().bytes() > 0) {
// we can guess a better default...
long l =
(long) ((0.3 * JvmInfo.jvmInfo().getMem().getDirectMemoryMax().bytes()) / workerCount);
defaultReceiverPredictor = Math.min(defaultReceiverPredictor, Math.max(l, 64 * 1024));
}
// See AdaptiveReceiveBufferSizePredictor#DEFAULT_XXX for default values in netty..., we can use
// higher ones for us, even fixed one
ByteSizeValue receivePredictorMin =
settings.getAsBytesSize(
"http.netty.receive_predictor_min",
settings.getAsBytesSize(
"http.netty.receive_predictor_size", new ByteSizeValue(defaultReceiverPredictor)));
ByteSizeValue receivePredictorMax =
settings.getAsBytesSize(
"http.netty.receive_predictor_max",
settings.getAsBytesSize(
"http.netty.receive_predictor_size", new ByteSizeValue(defaultReceiverPredictor)));
if (receivePredictorMax.bytes() == receivePredictorMin.bytes()) {
receiveBufferSizePredictorFactory =
new FixedReceiveBufferSizePredictorFactory((int) receivePredictorMax.bytes());
} else {
receiveBufferSizePredictorFactory =
new AdaptiveReceiveBufferSizePredictorFactory(
(int) receivePredictorMin.bytes(),
(int) receivePredictorMin.bytes(),
(int) receivePredictorMax.bytes());
}
this.compression = settings.getAsBoolean(SETTING_HTTP_COMPRESSION, false);
this.compressionLevel = settings.getAsInt(SETTING_HTTP_COMPRESSION_LEVEL, 6);
this.pipelining = settings.getAsBoolean(SETTING_PIPELINING, DEFAULT_SETTING_PIPELINING);
this.pipeliningMaxEvents =
settings.getAsInt(SETTING_PIPELINING_MAX_EVENTS, DEFAULT_SETTING_PIPELINING_MAX_EVENTS);
// validate max content length
if (maxContentLength.bytes() > Integer.MAX_VALUE) {
logger.warn(
"maxContentLength[" + maxContentLength + "] set to high value, resetting it to [100mb]");
maxContentLength = new ByteSizeValue(100, ByteSizeUnit.MB);
}
this.maxContentLength = maxContentLength;
logger.debug(
"using max_chunk_size[{}], max_header_size[{}], max_initial_line_length[{}], max_content_length[{}], receive_predictor[{}->{}], pipelining[{}], pipelining_max_events[{}]",
maxChunkSize,
maxHeaderSize,
maxInitialLineLength,
this.maxContentLength,
receivePredictorMin,
receivePredictorMax,
pipelining,
pipeliningMaxEvents);
}
@Inject
public TomcatHttpServerTransport(
final Settings settings,
final Environment environment,
final NetworkService networkService,
final ClusterName clusterName,
final Client client,
final SecurityService securityService) {
super(settings);
this.settings = settings;
this.securityService = securityService;
/*
* TODO check if keep alive is managed by tomcat copy custom headers to
* response check that user under tomcat/ea is running is not a
* privilieged iuser tomcat props apply: tomcat.XXX
*/
// _aliases test with more than one index mapped to an alias
/*
*
* http.max_initial_line_length not respected http.reset_cookies not
* respected workerCount http.cors.enabled http.cors.allow-origin
* http.cors.max-age http.cors.allow-methods http.cors.allow-headers
*
*
*
* http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/
* modules-network.html
*
* http://stackoverflow.com/questions/8038718/serializing-generic-java-
* object-to-json-using-jackson
* http://tomcatspnegoad.sourceforge.net/realms.html
*
* SSL options
*
*
*
* Realm options/login waffle, spnego ... security.kerberos.provider:
* waffle
*
* Hardening EA - dynamic script disable
*/
/*
*
*
*
*
*
*/
useSSL =
componentSettings.getAsBoolean(
"ssl.enabled", settings.getAsBoolean("security.ssl.enabled", false));
useClientAuth =
componentSettings.getAsBoolean(
"ssl.clientauth.enabled",
settings.getAsBoolean("security.ssl.clientauth.enabled", false));
kerberosMode =
componentSettings.get("kerberos.mode", settings.get("security.kerberos.mode", "none"));
port = componentSettings.get("port", settings.get("http.port", "8080"));
bindHost =
componentSettings.get(
"bind_host", settings.get("http.bind_host", settings.get("http.host")));
publishHost =
componentSettings.get(
"publish_host", settings.get("http.publish_host", settings.get("http.host")));
this.networkService = networkService;
ByteSizeValue maxContentLength =
componentSettings.getAsBytesSize(
"max_content_length",
settings.getAsBytesSize(
"http.max_content_length", new ByteSizeValue(100, ByteSizeUnit.MB)));
maxChunkSize =
componentSettings.getAsBytesSize(
"max_chunk_size",
settings.getAsBytesSize("http.max_chunk_size", new ByteSizeValue(8, ByteSizeUnit.KB)));
maxHeaderSize =
componentSettings.getAsBytesSize(
"max_header_size",
settings.getAsBytesSize("http.max_header_size", new ByteSizeValue(8, ByteSizeUnit.KB)));
blockingServer =
settings.getAsBoolean(
"http.blocking_server",
settings.getAsBoolean(TCP_BLOCKING_SERVER, settings.getAsBoolean(TCP_BLOCKING, false)));
tcpNoDelay =
componentSettings.getAsBoolean("tcp_no_delay", settings.getAsBoolean(TCP_NO_DELAY, true));
tcpKeepAlive =
componentSettings.getAsBoolean(
"tcp_keep_alive", settings.getAsBoolean(TCP_KEEP_ALIVE, true));
reuseAddress =
componentSettings.getAsBoolean(
"reuse_address",
settings.getAsBoolean(TCP_REUSE_ADDRESS, NetworkUtils.defaultReuseAddress()));
tcpSendBufferSize =
componentSettings.getAsBytesSize(
"tcp_send_buffer_size",
settings.getAsBytesSize(TCP_SEND_BUFFER_SIZE, TCP_DEFAULT_SEND_BUFFER_SIZE));
tcpReceiveBufferSize =
componentSettings.getAsBytesSize(
"tcp_receive_buffer_size",
settings.getAsBytesSize(TCP_RECEIVE_BUFFER_SIZE, TCP_DEFAULT_RECEIVE_BUFFER_SIZE));
compression = settings.getAsBoolean("http.compression", false);
compressionLevel = settings.getAsInt("http.compression_level", 6);
// validate max content length
if (maxContentLength.bytes() > Integer.MAX_VALUE) {
logger.warn(
"maxContentLength[" + maxContentLength + "] set to high value, resetting it to [100mb]");
maxContentLength = new ByteSizeValue(100, ByteSizeUnit.MB);
}
this.maxContentLength = maxContentLength;
logger.debug("port: " + port);
logger.debug("bindHost: " + bindHost);
logger.debug("publishHost: " + publishHost);
logger.debug("componentsettings: " + componentSettings.getAsMap());
logger.debug("settings: " + settings.getAsMap());
}
