@Override public NetServer createNetServer() { return createNetServer(new NetServerOptions()); }
private NetServerOptions getServerOptions() { NetServerOptions serverOptions = new NetServerOptions(this.options.toJson()); setCertOptions(serverOptions, options.getKeyCertOptions()); setTrustOptions(serverOptions, options.getTrustOptions()); return serverOptions; }
public NetServerImpl(VertxInternal vertx, NetServerOptions options) { this.vertx = vertx; this.options = new NetServerOptions(options); this.sslHelper = new SSLHelper(options, options.getKeyCertOptions(), options.getTrustOptions()); this.creatingContext = vertx.getContext(); this.logEnabled = options.getLogActivity(); if (creatingContext != null) { creatingContext.addCloseHook(this); } }
@Test public void testDummyNetServerMetrics() { NetServer server = vertx.createNetServer(new NetServerOptions()); assertFalse(server.isMetricsEnabled()); }
@Override public void start() throws Exception { NetServerOptions options = new NetServerOptions() .setSsl(true).setKeyStoreOptions(new JksOptions().setPath("server-keystore.jks").setPassword("wibble")); vertx.createNetServer(options).connectHandler(sock -> { // Create a pump Pump.pump(sock, sock).start(); }).listen(1234); System.out.println("Echo server is now listening"); } }
@Test public void testListenInvalidPort() { /* Port 80 is free to use by any application on Windows, so this test fails. */ Assume.assumeFalse(System.getProperty("os.name").startsWith("Windows")); server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(80)); server.connectHandler((netSocket) -> { }).listen(ar -> { assertTrue(ar.failed()); assertFalse(ar.succeeded()); assertNotNull(ar.cause()); testComplete(); }); await(); }
@Test public void testListenInvalidHost() { server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(1234).setHost("uhqwduhqwudhqwuidhqwiudhqwudqwiuhd")); server.connectHandler(netSocket -> { }).listen(ar -> { assertTrue(ar.failed()); assertFalse(ar.succeeded()); assertNotNull(ar.cause()); testComplete(); }); await(); }
@Test public void testSharedServersRoundRobinWithOtherServerRunningOnDifferentPort() throws Exception { CountDownLatch latch = new CountDownLatch(1); // Have a server running on a different port to make sure it doesn't interact server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(4321)); server.connectHandler(sock -> { fail("Should not connect"); }).listen(ar2 -> { if (ar2.succeeded()) { latch.countDown(); } else { fail("Failed to bind server"); } }); awaitLatch(latch); testSharedServersRoundRobin(); }
@Test public void testListenOnWildcardPort() { server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(0)); server.connectHandler((netSocket) -> { }).listen(ar -> { assertFalse(ar.failed()); assertTrue(ar.succeeded()); assertNull(ar.cause()); assertTrue(server.actualPort() > 1024); assertEquals(server, ar.result()); testComplete(); }); await(); }
@Test public void testNetSocketStreamCallbackIsAsync() { this.server = vertx.createNetServer(new NetServerOptions()); AtomicInteger done = new AtomicInteger(); ReadStream<NetSocket> stream = server.connectStream();
@Test public void testServerIdleTimeout() { server.close(); NetServerOptions netServerOptions = new NetServerOptions(); netServerOptions.setIdleTimeout(1000); netServerOptions.setIdleTimeoutUnit(TimeUnit.MILLISECONDS); server = vertx.createNetServer(netServerOptions); server.connectHandler(s -> {}).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, res -> { assertTrue(res.succeeded()); NetSocket socket = res.result(); socket.closeHandler(v -> testComplete()); }); }); await(); }
@Test public void testServerLogging() throws Exception { server.close(); server = vertx.createNetServer(new NetServerOptions().setLogActivity(true)); TestLoggerFactory factory = testLogging(); assertTrue(factory.hasName("io.netty.handler.logging.LoggingHandler")); }
@Test public void testServerOptionsCopiedBeforeUse() { server.close(); NetServerOptions options = new NetServerOptions().setPort(1234); server = vertx.createNetServer(options); // Now change something - but server should still listen at previous port options.setPort(1235); server.connectHandler(sock -> { testComplete(); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { assertTrue(ar2.succeeded()); }); }); await(); }
@Test public void testTLSHostnameCertCheckIncorrect() { server.close(); server = vertx.createNetServer(new NetServerOptions().setSsl(true).setPort(4043) .setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get())); server.connectHandler(netSocket -> netSocket.close()).listen(ar -> { NetClientOptions options = new NetClientOptions() .setHostnameVerificationAlgorithm("HTTPS") .setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()); NetClient client = vertx.createNetClient(options); client.connect(4043, "127.0.0.1", arSocket -> { if (arSocket.succeeded()) { NetSocket ns = arSocket.result(); ns.closeHandler(v -> { testComplete(); }); ns.upgradeToSsl(v -> { fail("this test should fail"); }); } else { fail(ar.cause()); } }); }); await(); }
@Test public void testNetServerInternalTLS() throws Exception { server.close(); server = vertx.createNetServer(new NetServerOptions() .setPort(1234) .setHost("localhost") .setSsl(true) .setKeyStoreOptions(Cert.SERVER_JKS.get())); testNetServerInternal_(new HttpClientOptions() .setSsl(true) .setTrustStoreOptions(Trust.SERVER_JKS.get()) , true); }
@Test public void testTLSHostnameCertCheckCorrect() { server.close(); server = vertx.createNetServer(new NetServerOptions().setSsl(true).setPort(4043) .setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get())); server.connectHandler(netSocket -> netSocket.close()).listen(ar -> { NetClientOptions options = new NetClientOptions() .setHostnameVerificationAlgorithm("HTTPS") .setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()); NetClient client = vertx.createNetClient(options); client.connect(4043, "localhost", arSocket -> { if (arSocket.succeeded()) { NetSocket ns = arSocket.result(); ns.exceptionHandler(th -> { fail(th); }); ns.upgradeToSsl(v -> { testComplete(); }); } else { fail(ar.cause()); } }); }); await(); }
@Test public void testHostVerificationHttpsNotMatching() { server.close(); NetServerOptions options = new NetServerOptions() .setPort(1234) .setHost("localhost") .setSsl(true) .setKeyStoreOptions(new JksOptions().setPath("tls/mim-server-keystore.jks").setPassword("wibble")); NetServer server = vertx.createNetServer(options); NetClientOptions clientOptions = new NetClientOptions() .setSsl(true) .setTrustAll(true) .setHostnameVerificationAlgorithm("HTTPS"); NetClient client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { }); server.listen(ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { //Should not be able to connect assertTrue(ar2.failed()); testComplete(); }); }); await(); }
@Test public void testHostVerificationHttpsMatching() { server.close(); NetServerOptions options = new NetServerOptions() .setPort(1234) .setHost("localhost") .setSsl(true) .setKeyStoreOptions(new JksOptions().setPath("tls/server-keystore.jks").setPassword("wibble")); NetServer server = vertx.createNetServer(options); NetClientOptions clientOptions = new NetClientOptions() .setSsl(true) .setTrustAll(true) .setHostnameVerificationAlgorithm("HTTPS"); NetClient client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { }); server.listen(ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { //Should be able to connect assertTrue(ar2.succeeded()); testComplete(); }); }); await(); }
@Test public void testCloseCompletionHandlerNotCalledWhenActualServerFailed() { server.close(); server = vertx.createNetServer( new NetServerOptions() .setSsl(true) .setPemKeyCertOptions(new PemKeyCertOptions().setKeyPath("invalid"))) .connectHandler(c -> { }); try { server.listen(10000, r -> fail()); } catch (Exception ignore) { // Expected } server.close(onSuccess(v -> { testComplete(); })); await(); }
@Test @SuppressWarnings("deprecation") public void testDefaultServerOptionsJson() { NetServerOptions def = new NetServerOptions(); NetServerOptions json = new NetServerOptions(new JsonObject()); assertEquals(def.isClientAuthRequired(), json.isClientAuthRequired()); assertEquals(def.getCrlPaths(), json.getCrlPaths()); assertEquals(def.getCrlValues(), json.getCrlValues()); assertEquals(def.getAcceptBacklog(), json.getAcceptBacklog()); assertEquals(def.getPort(), json.getPort()); assertEquals(def.getHost(), json.getHost()); assertEquals(def.isClientAuthRequired(), json.isClientAuthRequired()); assertEquals(def.getCrlPaths(), json.getCrlPaths()); assertEquals(def.getCrlValues(), json.getCrlValues()); assertEquals(def.getAcceptBacklog(), json.getAcceptBacklog()); assertEquals(def.getPort(), json.getPort()); assertEquals(def.getHost(), json.getHost()); assertEquals(def.isTcpNoDelay(), json.isTcpNoDelay()); assertEquals(def.isTcpKeepAlive(), json.isTcpKeepAlive()); assertEquals(def.getSoLinger(), json.getSoLinger()); assertEquals(def.isUsePooledBuffers(), json.isUsePooledBuffers()); assertEquals(def.isSsl(), json.isSsl()); assertEquals(def.isUseAlpn(), json.isUseAlpn()); assertEquals(def.getSslEngineOptions(), json.getSslEngineOptions()); assertEquals(def.isSni(), json.isSni()); }