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()); }