public void start() { final Xnio xnio; try { // Do what org.jboss.as.remoting.XnioUtil does xnio = Xnio.getInstance( null, Module.getModuleFromCallerModuleLoader( ModuleIdentifier.fromString("org.jboss.xnio.nio")) .getClassLoader()); } catch (Exception e) { throw new IllegalStateException(e.getLocalizedMessage()); } try { // TODO make this configurable worker = xnio.createWorker( OptionMap.builder() .set(Options.WORKER_IO_THREADS, 4) .set(Options.CONNECTION_HIGH_WATER, 1000000) .set(Options.CONNECTION_LOW_WATER, 1000000) .set(Options.WORKER_TASK_CORE_THREADS, 10) .set(Options.WORKER_TASK_MAX_THREADS, 12) .set(Options.TCP_NODELAY, true) .set(Options.CORK, true) .getMap()); Builder serverOptionsBuilder = OptionMap.builder().set(Options.TCP_NODELAY, true).set(Options.REUSE_ADDRESSES, true); ChannelListener acceptListener = ChannelListeners.openListenerAdapter(openListener); if (httpAddress != null) { normalServer = worker.createStreamConnectionServer( httpAddress, acceptListener, serverOptionsBuilder.getMap()); normalServer.resumeAccepts(); } if (secureAddress != null) { SSLContext sslContext = securityRealm.getSSLContext(); Set<AuthMechanism> supportedMechanisms = securityRealm.getSupportedAuthenticationMechanisms(); if (supportedMechanisms.contains(AuthMechanism.CLIENT_CERT)) { if (supportedMechanisms.contains(AuthMechanism.DIGEST) || supportedMechanisms.contains(AuthMechanism.PLAIN)) { // Username / Password auth is possible so don't mandate a client certificate. serverOptionsBuilder.set(SSL_CLIENT_AUTH_MODE, REQUESTED); } else { serverOptionsBuilder.set(SSL_CLIENT_AUTH_MODE, REQUIRED); } } OptionMap secureOptions = serverOptionsBuilder.getMap(); XnioSsl xnioSsl = new JsseXnioSsl(worker.getXnio(), secureOptions, sslContext); secureServer = xnioSsl.createSslConnectionServer(worker, secureAddress, acceptListener, secureOptions); secureServer.resumeAccepts(); } } catch (IOException e) { throw new RuntimeException(e); } }
public void start() { final Xnio xnio; try { // Do what org.jboss.as.remoting.XnioUtil does xnio = Xnio.getInstance( null, Module.getModuleFromCallerModuleLoader( ModuleIdentifier.fromString("org.jboss.xnio.nio")) .getClassLoader()); } catch (Exception e) { throw new IllegalStateException(e.getLocalizedMessage()); } try { // TODO make this configurable worker = xnio.createWorker( OptionMap.builder() .set(Options.WORKER_IO_THREADS, 2) .set(Options.WORKER_TASK_CORE_THREADS, 5) .set(Options.WORKER_TASK_MAX_THREADS, 10) .set(Options.TCP_NODELAY, true) .set(Options.CORK, true) .getMap()); Builder serverOptionsBuilder = OptionMap.builder().set(Options.TCP_NODELAY, true).set(Options.REUSE_ADDRESSES, true); ChannelListener acceptListener = ChannelListeners.openListenerAdapter(openListener); if (httpAddress != null) { normalServer = worker.createStreamConnectionServer( httpAddress, acceptListener, serverOptionsBuilder.getMap()); normalServer.resumeAccepts(); } if (secureAddress != null) { if (sslClientAuthMode != null) { serverOptionsBuilder.set(SSL_CLIENT_AUTH_MODE, sslClientAuthMode); } OptionMap secureOptions = serverOptionsBuilder.getMap(); XnioSsl xnioSsl = new UndertowXnioSsl(worker.getXnio(), secureOptions, sslContext); secureServer = xnioSsl.createSslConnectionServer(worker, secureAddress, acceptListener, secureOptions); secureServer.resumeAccepts(); } } catch (IOException e) { throw new RuntimeException(e); } }
@BeforeClass public static void setup() throws IOException { DefaultServer.setRootHandler(AutobahnWebSocketServer.getRootHandler()); Xnio xnio = Xnio.getInstance(DefaultServer.class.getClassLoader()); worker = xnio.createWorker( OptionMap.builder() .set(Options.WORKER_IO_THREADS, 2) .set(Options.CONNECTION_HIGH_WATER, 1000000) .set(Options.CONNECTION_LOW_WATER, 1000000) .set(Options.WORKER_TASK_CORE_THREADS, 30) .set(Options.WORKER_TASK_MAX_THREADS, 30) .set(Options.TCP_NODELAY, true) .set(Options.CORK, true) .getMap()); }
public void start() throws IOException { log.infof("Starting JMX Remoting Server %s", Version.getVersionString()); // Initialise general Remoting - this step would be implemented elsewhere when // running within an application server. final Xnio xnio = Xnio.getInstance(); endpoint = Remoting.createEndpoint("JMXRemoting", xnio, OptionMap.EMPTY); endpoint.addConnectionProvider( "remote", new RemoteConnectionProviderFactory(), OptionMap.EMPTY); final NetworkServerProvider nsp = endpoint.getConnectionProviderInterface("remote", NetworkServerProvider.class); final SocketAddress bindAddress = new InetSocketAddress(host, listenerPort); final OptionMap serverOptions = createOptionMap(); server = nsp.createServer(bindAddress, serverOptions, authenticationProvider, null); Map<String, Object> configMap = new HashMap<String, Object>(); if (excludedVersions != null) { configMap.put(EXCLUDED_VERSIONS, excludedVersions); } // Initialise the components that will provide JMX connectivity. if (mbeanServerLocator == null) { connectorServer = new RemotingConnectorServer( mbeanServer, endpoint, configMap, serverMessageEventHandlerFactory); connectorServer.start(); } else { delegatingServer = new DelegatingRemotingConnectorServer( mbeanServerLocator, endpoint, configMap, serverMessageEventHandlerFactory); delegatingServer.start(); } }
public UndertowXhrTransport(OptionMap optionMap) throws IOException { Assert.notNull(optionMap, "OptionMap is required"); this.optionMap = optionMap; this.httpClient = UndertowClient.getInstance(); this.worker = Xnio.getInstance().createWorker(optionMap); this.undertowBufferSupport = (undertow13Present ? new Undertow13BufferSupport() : new UndertowXnioBufferSupport()); }
public static void main(String[] args) throws Exception { // First define the listener that actually is run on each connection. final ChannelListener<ConnectedStreamChannel> readListener = new ChannelListener<ConnectedStreamChannel>() { public void handleEvent(ConnectedStreamChannel channel) { final ByteBuffer buffer = ByteBuffer.allocate(512); int res; try { while ((res = channel.read(buffer)) > 0) { buffer.flip(); Channels.writeBlocking(channel, buffer); } // make sure everything is flushed out Channels.flushBlocking(channel); if (res == -1) { channel.close(); } else { channel.resumeReads(); } } catch (IOException e) { e.printStackTrace(); IoUtils.safeClose(channel); } } }; // Create an accept listener. final ChannelListener<AcceptingChannel<ConnectedStreamChannel>> acceptListener = new ChannelListener<AcceptingChannel<ConnectedStreamChannel>>() { public void handleEvent(final AcceptingChannel<ConnectedStreamChannel> channel) { try { ConnectedStreamChannel accepted; // channel is ready to accept zero or more connections while ((accepted = channel.accept()) != null) { System.out.println("accepted " + accepted.getPeerAddress()); // stream channel has been accepted at this stage. accepted.getReadSetter().set(readListener); // read listener is set; start it up accepted.resumeReads(); } } catch (IOException ignored) { } } }; final XnioWorker worker = Xnio.getInstance().createWorker(OptionMap.EMPTY); // Create the server. AcceptingChannel<? extends ConnectedStreamChannel> server = worker.createStreamServer(new InetSocketAddress(12345), acceptListener, OptionMap.EMPTY); // lets start accepting connections server.resumeAccepts(); System.out.println("Listening on " + server.getLocalAddress()); }
private void startServer() throws Exception { final Xnio xnio = Xnio.getInstance(); endpoint = Remoting.createEndpoint("RemoteNaming", xnio, OptionMap.EMPTY); endpoint.addConnectionProvider( "remote", new RemoteConnectionProviderFactory(), OptionMap.EMPTY); final NetworkServerProvider nsp = endpoint.getConnectionProviderInterface("remote", NetworkServerProvider.class); final SocketAddress bindAddress = new InetSocketAddress("localhost", 7999); final OptionMap serverOptions = TestUtils.createOptionMap(); server = nsp.createServer( bindAddress, serverOptions, new TestUtils.DefaultAuthenticationHandler(), null); remoteNamingService = new RemoteNamingService(localContext, Executors.newFixedThreadPool(10)); remoteNamingService.start(endpoint); serverStopped = false; }
public void start() throws IOException { log.infof("Starting JMX Remoting Server %s", Version.getVersionString()); // Initialise general Remoting - this step would be implemented elsewhere when // running within an application server. final Xnio xnio = Xnio.getInstance(); endpoint = Remoting.createEndpoint("JMXRemoting", xnio, OptionMap.EMPTY); endpoint.addConnectionProvider( "remote", new RemoteConnectionProviderFactory(), OptionMap.EMPTY); final NetworkServerProvider nsp = endpoint.getConnectionProviderInterface("remote", NetworkServerProvider.class); final SocketAddress bindAddress = new InetSocketAddress("localhost", listenerPort); final OptionMap serverOptions = createOptionMap(); server = nsp.createServer(bindAddress, serverOptions, authenticationProvider, null); // Initialise the components that will provide JMX connectivity. connectorServer = new RemotingConnectorServer(mbeanServer, endpoint); connectorServer.start(); }
private WebSocketContainer getDefaultContainer() { if (defaultContainerDisabled) { return null; } if (defaultContainer != null) { return defaultContainer; } synchronized (UndertowContainerProvider.class) { if (defaultContainer == null) { try { // this is not great, as we have no way to control the lifecycle // but there is not much we can do // todo: what options should we use here? XnioWorker worker = Xnio.getInstance().createWorker(OptionMap.create(Options.THREAD_DAEMON, true)); Pool<ByteBuffer> buffers = new ByteBufferSlicePool( directBuffers ? BufferAllocator.DIRECT_BYTE_BUFFER_ALLOCATOR : BufferAllocator.BYTE_BUFFER_ALLOCATOR, 1024, 10240); defaultContainer = new ServerWebSocketContainer( defaultIntrospector, UndertowContainerProvider.class.getClassLoader(), worker, buffers, new CompositeThreadSetupAction(Collections.<ThreadSetupAction>emptyList()), !invokeInIoThread); } catch (IOException e) { throw new RuntimeException(e); } } return defaultContainer; } }
public synchronized void start() { xnio = Xnio.getInstance(Undertow.class.getClassLoader()); channels = new ArrayList<>(); try { worker = xnio.createWorker( OptionMap.builder() .set(Options.WORKER_IO_THREADS, ioThreads) .set(Options.CONNECTION_HIGH_WATER, 1000000) .set(Options.CONNECTION_LOW_WATER, 1000000) .set(Options.WORKER_TASK_CORE_THREADS, workerThreads) .set(Options.WORKER_TASK_MAX_THREADS, workerThreads) .set(Options.TCP_NODELAY, true) .set(Options.CORK, true) .addAll(workerOptions) .getMap()); OptionMap socketOptions = OptionMap.builder() .set(Options.WORKER_IO_THREADS, ioThreads) .set(Options.TCP_NODELAY, true) .set(Options.REUSE_ADDRESSES, true) .set(Options.BALANCING_TOKENS, 1) .set(Options.BALANCING_CONNECTIONS, 2) .set(Options.BACKLOG, 1000) .addAll(this.socketOptions) .getMap(); Pool<ByteBuffer> buffers = new ByteBufferSlicePool( directBuffers ? BufferAllocator.DIRECT_BYTE_BUFFER_ALLOCATOR : BufferAllocator.BYTE_BUFFER_ALLOCATOR, bufferSize, bufferSize * buffersPerRegion); for (ListenerConfig listener : listeners) { final HttpHandler rootHandler = listener.rootHandler != null ? listener.rootHandler : this.rootHandler; if (listener.type == ListenerType.AJP) { AjpOpenListener openListener = new AjpOpenListener(buffers, serverOptions); openListener.setRootHandler(rootHandler); ChannelListener<AcceptingChannel<StreamConnection>> acceptListener = ChannelListeners.openListenerAdapter(openListener); AcceptingChannel<? extends StreamConnection> server = worker.createStreamConnectionServer( new InetSocketAddress(Inet4Address.getByName(listener.host), listener.port), acceptListener, socketOptions); server.resumeAccepts(); channels.add(server); } else { OptionMap undertowOptions = OptionMap.builder() .set(UndertowOptions.BUFFER_PIPELINED_DATA, true) .addAll(serverOptions) .getMap(); if (listener.type == ListenerType.HTTP) { HttpOpenListener openListener = new HttpOpenListener(buffers, undertowOptions); openListener.setRootHandler(rootHandler); ChannelListener<AcceptingChannel<StreamConnection>> acceptListener = ChannelListeners.openListenerAdapter(openListener); AcceptingChannel<? extends StreamConnection> server = worker.createStreamConnectionServer( new InetSocketAddress(Inet4Address.getByName(listener.host), listener.port), acceptListener, socketOptions); server.resumeAccepts(); channels.add(server); } else if (listener.type == ListenerType.HTTPS) { ChannelListener<StreamConnection> openListener; HttpOpenListener httpOpenListener = new HttpOpenListener(buffers, undertowOptions); httpOpenListener.setRootHandler(rootHandler); boolean spdy = serverOptions.get(UndertowOptions.ENABLE_SPDY, false); boolean http2 = serverOptions.get(UndertowOptions.ENABLE_HTTP2, false); if (spdy || http2) { AlpnOpenListener alpn = new AlpnOpenListener(buffers, undertowOptions, httpOpenListener); if (spdy) { SpdyOpenListener spdyListener = new SpdyOpenListener( buffers, new ByteBufferSlicePool(BufferAllocator.BYTE_BUFFER_ALLOCATOR, 1024, 1024), undertowOptions); spdyListener.setRootHandler(rootHandler); alpn.addProtocol(SpdyOpenListener.SPDY_3_1, spdyListener, 5); } if (http2) { Http2OpenListener http2Listener = new Http2OpenListener(buffers, undertowOptions); http2Listener.setRootHandler(rootHandler); alpn.addProtocol(Http2OpenListener.HTTP2, http2Listener, 10); alpn.addProtocol(Http2OpenListener.HTTP2_14, http2Listener, 7); } openListener = alpn; } else { openListener = httpOpenListener; } ChannelListener<AcceptingChannel<StreamConnection>> acceptListener = ChannelListeners.openListenerAdapter(openListener); XnioSsl xnioSsl; if (listener.sslContext != null) { xnioSsl = new UndertowXnioSsl( xnio, OptionMap.create(Options.USE_DIRECT_BUFFERS, true), listener.sslContext); } else { xnioSsl = xnio.getSslProvider( listener.keyManagers, listener.trustManagers, OptionMap.create(Options.USE_DIRECT_BUFFERS, true)); } AcceptingChannel<SslConnection> sslServer = xnioSsl.createSslConnectionServer( worker, new InetSocketAddress(Inet4Address.getByName(listener.host), listener.port), (ChannelListener) acceptListener, socketOptions); sslServer.resumeAccepts(); channels.add(sslServer); } } } } catch (Exception e) { throw new RuntimeException(e); } }
public void testAcceptor() throws Exception { threadFactory.clear(); log.info("Test: testAcceptor"); final CountDownLatch ioLatch = new CountDownLatch(4); final CountDownLatch closeLatch = new CountDownLatch(2); final AtomicBoolean clientOpened = new AtomicBoolean(); final AtomicBoolean clientReadOnceOK = new AtomicBoolean(); final AtomicBoolean clientReadDoneOK = new AtomicBoolean(); final AtomicBoolean clientReadTooMuch = new AtomicBoolean(); final AtomicBoolean clientWriteOK = new AtomicBoolean(); final AtomicBoolean serverOpened = new AtomicBoolean(); final AtomicBoolean serverReadOnceOK = new AtomicBoolean(); final AtomicBoolean serverReadDoneOK = new AtomicBoolean(); final AtomicBoolean serverReadTooMuch = new AtomicBoolean(); final AtomicBoolean serverWriteOK = new AtomicBoolean(); final byte[] bytes = "Ummagumma!".getBytes("UTF-8"); final Xnio xnio = Xnio.getInstance("nio"); final ReadChannelThread readChannelThread = xnio.createReadChannelThread(threadFactory); final ReadChannelThread clientReadChannelThread = xnio.createReadChannelThread(threadFactory); final WriteChannelThread writeChannelThread = xnio.createWriteChannelThread(threadFactory); final WriteChannelThread clientWriteChannelThread = xnio.createWriteChannelThread(threadFactory); final ConnectionChannelThread connectionChannelThread = xnio.createConnectionChannelThread(threadFactory); try { final FutureResult<InetSocketAddress> futureAddressResult = new FutureResult<InetSocketAddress>(); final IoFuture<InetSocketAddress> futureAddress = futureAddressResult.getIoFuture(); final IoFuture<? extends ConnectedStreamChannel> futureConnection = xnio.acceptStream( new InetSocketAddress(Inet4Address.getByAddress(new byte[] {127, 0, 0, 1}), 0), connectionChannelThread, clientReadChannelThread, clientWriteChannelThread, new ChannelListener<ConnectedStreamChannel>() { private final ByteBuffer inboundBuf = ByteBuffer.allocate(512); private int readCnt = 0; private final ByteBuffer outboundBuf = ByteBuffer.wrap(bytes); public void handleEvent(final ConnectedStreamChannel channel) { channel .getCloseSetter() .set( new ChannelListener<ConnectedStreamChannel>() { public void handleEvent(final ConnectedStreamChannel channel) { closeLatch.countDown(); } }); channel .getReadSetter() .set( new ChannelListener<ConnectedStreamChannel>() { public void handleEvent(final ConnectedStreamChannel channel) { try { final int res = channel.read(inboundBuf); if (res == 0) { channel.resumeReads(); } else if (res == -1) { serverReadDoneOK.set(true); ioLatch.countDown(); channel.shutdownReads(); } else { final int ttl = readCnt += res; if (ttl == bytes.length) { serverReadOnceOK.set(true); } else if (ttl > bytes.length) { serverReadTooMuch.set(true); IoUtils.safeClose(channel); return; } channel.resumeReads(); } } catch (IOException e) { log.errorf(e, "Server read failed"); IoUtils.safeClose(channel); } } }); channel .getWriteSetter() .set( new ChannelListener<ConnectedStreamChannel>() { public void handleEvent(final ConnectedStreamChannel channel) { try { channel.write(outboundBuf); if (!outboundBuf.hasRemaining()) { serverWriteOK.set(true); Channels.shutdownWritesBlocking(channel); ioLatch.countDown(); } } catch (IOException e) { log.errorf(e, "Server write failed"); IoUtils.safeClose(channel); } } }); channel.resumeReads(); channel.resumeWrites(); serverOpened.set(true); } }, new ChannelListener<BoundChannel>() { public void handleEvent(final BoundChannel channel) { futureAddressResult.setResult(channel.getLocalAddress(InetSocketAddress.class)); } }, OptionMap.create(Options.REUSE_ADDRESSES, Boolean.TRUE)); final InetSocketAddress localAddress = futureAddress.get(); final IoFuture<? extends ConnectedStreamChannel> ioFuture = xnio.connectStream( localAddress, connectionChannelThread, readChannelThread, writeChannelThread, new ChannelListener<ConnectedStreamChannel>() { private final ByteBuffer inboundBuf = ByteBuffer.allocate(512); private int readCnt = 0; private final ByteBuffer outboundBuf = ByteBuffer.wrap(bytes); public void handleEvent(final ConnectedStreamChannel channel) { channel .getCloseSetter() .set( new ChannelListener<ConnectedStreamChannel>() { public void handleEvent(final ConnectedStreamChannel channel) { closeLatch.countDown(); } }); channel .getReadSetter() .set( new ChannelListener<ConnectedStreamChannel>() { public void handleEvent(final ConnectedStreamChannel channel) { try { final int res = channel.read(inboundBuf); if (res == 0) { channel.resumeReads(); } else if (res == -1) { channel.shutdownReads(); clientReadDoneOK.set(true); ioLatch.countDown(); } else { final int ttl = readCnt += res; if (ttl == bytes.length) { clientReadOnceOK.set(true); } else if (ttl > bytes.length) { clientReadTooMuch.set(true); IoUtils.safeClose(channel); return; } channel.resumeReads(); } } catch (IOException e) { log.errorf(e, "Client read failed"); IoUtils.safeClose(channel); } } }); channel .getWriteSetter() .set( new ChannelListener<ConnectedStreamChannel>() { public void handleEvent(final ConnectedStreamChannel channel) { try { channel.write(outboundBuf); if (!outboundBuf.hasRemaining()) { clientWriteOK.set(true); Channels.shutdownWritesBlocking(channel); ioLatch.countDown(); } } catch (IOException e) { log.errorf(e, "Client write failed"); IoUtils.safeClose(channel); } } }); channel.resumeReads(); channel.resumeWrites(); clientOpened.set(true); } }, null, OptionMap.EMPTY); assertTrue("Read timed out", ioLatch.await(500L, TimeUnit.MILLISECONDS)); assertTrue("Close timed out", closeLatch.await(500L, TimeUnit.MILLISECONDS)); assertFalse("Client read too much", clientReadTooMuch.get()); assertTrue("Client read OK", clientReadOnceOK.get()); assertTrue("Client read done", clientReadDoneOK.get()); assertTrue("Client write OK", clientWriteOK.get()); assertFalse("Server read too much", serverReadTooMuch.get()); assertTrue("Server read OK", serverReadOnceOK.get()); assertTrue("Server read done", serverReadDoneOK.get()); assertTrue("Server write OK", serverWriteOK.get()); } finally { readChannelThread.shutdown(); writeChannelThread.shutdown(); clientReadChannelThread.shutdown(); clientWriteChannelThread.shutdown(); connectionChannelThread.shutdown(); } threadFactory.await(); }
private void doConnectionTest( final Runnable body, final ChannelListener<? super ConnectedStreamChannel> clientHandler, final ChannelListener<? super ConnectedStreamChannel> serverHandler) throws Exception { Xnio xnio = Xnio.getInstance("nio", NioTcpTestCase.class.getClassLoader()); final ConnectionChannelThread connectionChannelThread = xnio.createConnectionChannelThread(threadFactory); final ConnectionChannelThread serverChannelThread = xnio.createConnectionChannelThread(threadFactory); final ReadChannelThread readChannelThread = xnio.createReadChannelThread(threadFactory); final ReadChannelThread clientReadChannelThread = xnio.createReadChannelThread(threadFactory); final WriteChannelThread writeChannelThread = xnio.createWriteChannelThread(threadFactory); final WriteChannelThread clientWriteChannelThread = xnio.createWriteChannelThread(threadFactory); try { final AcceptingChannel<? extends ConnectedStreamChannel> server = xnio.createStreamServer( new InetSocketAddress( Inet4Address.getByAddress(new byte[] {127, 0, 0, 1}), SERVER_PORT), serverChannelThread, ChannelListeners.<ConnectedStreamChannel>openListenerAdapter( readChannelThread, writeChannelThread, new CatchingChannelListener<ConnectedStreamChannel>( serverHandler, threadFactory)), OptionMap.create(Options.REUSE_ADDRESSES, Boolean.TRUE)); server.resumeAccepts(); try { final IoFuture<? extends ConnectedStreamChannel> ioFuture = xnio.connectStream( new InetSocketAddress( Inet4Address.getByAddress(new byte[] {127, 0, 0, 1}), SERVER_PORT), connectionChannelThread, clientReadChannelThread, clientWriteChannelThread, new CatchingChannelListener<ConnectedStreamChannel>(clientHandler, threadFactory), null, OptionMap.EMPTY); final ConnectedStreamChannel channel = ioFuture.get(); try { body.run(); channel.close(); server.close(); } catch (Exception e) { log.errorf(e, "Error running body"); throw e; } catch (Error e) { log.errorf(e, "Error running body"); throw e; } finally { IoUtils.safeClose(channel); } } finally { IoUtils.safeClose(server); } } finally { connectionChannelThread.shutdown(); serverChannelThread.shutdown(); clientReadChannelThread.shutdown(); clientWriteChannelThread.shutdown(); readChannelThread.shutdown(); writeChannelThread.shutdown(); } connectionChannelThread.awaitTermination(); serverChannelThread.awaitTermination(); readChannelThread.awaitTermination(); writeChannelThread.awaitTermination(); clientReadChannelThread.awaitTermination(); clientWriteChannelThread.awaitTermination(); }