Integer shutdownTimeoutMillis = serverOptions.get(UndertowOptions.SHUTDOWN_TIMEOUT); worker.shutdown(); try { if (shutdownTimeoutMillis == null) { worker.awaitTermination(); } else { if (!worker.awaitTermination(shutdownTimeoutMillis, TimeUnit.MILLISECONDS)) { worker.shutdownNow(); worker.shutdownNow(); throw new RuntimeException(e);
@Override public void run() { worker.execute(new Runnable() { @Override public void run() { long currentTime = System.currentTimeMillis(); if(currentTime >= expireTime) { invalidate(null, SessionListener.SessionDestroyedReason.TIMEOUT); } else { timerCancelKey = WorkerUtils.executeAfter(executor, cancelTask, expireTime - currentTime, TimeUnit.MILLISECONDS); } } }); } };
@Override void startListening(XnioWorker worker, InetSocketAddress socketAddress, ChannelListener<AcceptingChannel<StreamConnection>> acceptListener) throws IOException { server = worker.createStreamConnectionServer(socketAddress, acceptListener, OptionMap.builder().addAll(commonOptions).addAll(socketOptions).getMap()); server.resumeAccepts(); final InetSocketAddress boundAddress = server.getLocalAddress(InetSocketAddress.class); UndertowLogger.ROOT_LOGGER.listenerStarted("AJP", getName(), NetworkUtils.formatIPAddressForURI(boundAddress.getAddress()), boundAddress.getPort()); }
OptionMap socketOptions = OptionMap.builder() .set(Options.WORKER_IO_THREADS, worker.getIoThreadCount()) OptionMap serverOptions = OptionMap.builder() AcceptingChannel<? extends StreamConnection> server = worker.createStreamConnectionServer(new InetSocketAddress(Inet4Address.getByName(listener.host), listener.port), acceptListener, socketOptionsWithOverrides); server.resumeAccepts(); channels.add(server); AcceptingChannel<? extends StreamConnection> server = worker.createStreamConnectionServer(new InetSocketAddress(Inet4Address.getByName(listener.host), listener.port), acceptListener, socketOptionsWithOverrides); server.resumeAccepts(); channels.add(server); if (listener.useProxyProtocol) { ChannelListener<AcceptingChannel<StreamConnection>> acceptListener = ChannelListeners.openListenerAdapter(new ProxyProtocolOpenListener(openListener, xnioSsl, buffers, socketOptionsWithOverrides)); sslServer = worker.createStreamConnectionServer(new InetSocketAddress(Inet4Address.getByName(listener.host), listener.port), (ChannelListener) acceptListener, socketOptionsWithOverrides); } else { ChannelListener<AcceptingChannel<StreamConnection>> acceptListener = ChannelListeners.openListenerAdapter(openListener); worker.shutdownNow();
modClusterBuilder = ModCluster.builder(worker); } else { OptionMap.Builder builder = OptionMap.builder(); builder.set(Options.USE_DIRECT_BUFFERS, true); OptionMap combined = builder.getMap(); XnioSsl xnioSsl = new UndertowXnioSsl(worker.getXnio(), combined, sslContext); modClusterBuilder = ModCluster.builder(worker, UndertowClient.getInstance(), xnioSsl); .setAdvertiseAddress(advertiseBinding.getSocketAddress().getAddress().getHostAddress()) .setAdvertiseGroup(multicastAddress.getHostAddress()) .setAdvertisePort(advertiseBinding.getMulticastPort()) builder.setManagementHost(managementSocketBinding.getValue().getSocketAddress().getHostString()); builder.setManagementPort(managementSocketBinding.getValue().getSocketAddress().getPort());
private AcceptingChannel<? extends StreamConnection> createServer(int sourcePort, int targetPort) throws IllegalArgumentException, IOException { OptionMap socketOptions = OptionMap.builder() .set(Options.WORKER_IO_THREADS, 16) .set(Options.TCP_NODELAY, true) .set(Options.REUSE_ADDRESSES, true) .getMap(); ChannelListener<AcceptingChannel<StreamConnection>> acceptListener = ChannelListeners.openListenerAdapter( new PortForwardOpenListener(connection, portForwardURI.getPath(), targetPort, requestId, bufferPoolSlice, OptionMap.EMPTY)); AcceptingChannel<? extends StreamConnection> server = xnioWorker.createStreamConnectionServer(new InetSocketAddress(portForwardBindAddress, sourcePort), acceptListener, socketOptions); server.resumeAccepts(); return server; }
@Override protected void startListening(XnioWorker worker, InetSocketAddress socketAddress, ChannelListener<AcceptingChannel<StreamConnection>> acceptListener) throws IOException { if(proxyProtocol) { sslServer = worker.createStreamConnectionServer(socketAddress, (ChannelListener) acceptListener, getSSLOptions(sslContextSupplier.get())); } else { XnioSsl ssl = getSsl(); sslServer = ssl.createSslConnectionServer(worker, socketAddress, (ChannelListener) acceptListener, getSSLOptions(sslContextSupplier.get())); } sslServer.resumeAccepts(); final InetSocketAddress boundAddress = sslServer.getLocalAddress(InetSocketAddress.class); UndertowLogger.ROOT_LOGGER.listenerStarted("HTTPS", getName(), NetworkUtils.formatIPAddressForURI(boundAddress.getAddress()), boundAddress.getPort()); }
if (sslContext != null && (sslRequired || optionMap.get(Options.SSL_ENABLED, true) && optionMap.get(Options.SSL_STARTTLS, true))) { result = xnioWorker.createStreamConnectionServer(bindAddress, channel -> { final StreamConnection streamConnection = acceptAndConfigure(channel); if (streamConnection == null) return; final int realPort; if (peerAddress != null) { realHost = peerAddress.getHostString(); realPort = peerAddress.getPort(); } else { realHost = null; sslConnection = new JsseSslStreamConnection(streamConnection, engine, ! sslRequired); if (optionMap.contains(Options.SSL_CLIENT_AUTH_MODE)) try { sslConnection.setOption(Options.SSL_CLIENT_AUTH_MODE, optionMap.get(Options.SSL_CLIENT_AUTH_MODE)); } catch (IOException e) { }, optionMap); } else { result = xnioWorker.createStreamConnectionServer(bindAddress, channel -> { final StreamConnection streamConnection = acceptAndConfigure(channel); if (streamConnection == null) return;
URI.create(String.format(PORT_FWD, config.getMasterUrl(), config.getNamespace(), podName)); final Xnio xnio = Xnio.getInstance(); DEFAULT_OPTIONS = OptionMap.builder() .set(Options.WORKER_NAME, String.format("PortForwarding for %s/%s", config.getNamespace(), podName)) .set(Options.WORKER_IO_THREADS, 16) .set(Options.CONNECTION_HIGH_WATER, 400) .set(Options.CONNECTION_LOW_WATER, 200) .set(Options.WORKER_TASK_CORE_THREADS, 16) .getMap(); final XnioSsl xnioSsl = xnio.getSslProvider(SSLUtils.keyManagers(config), new TrustManager[] {new X509TrustManager() { public void checkClientTrusted(X509Certificate[] chain, String s) { this.xnioWorker = xnio.createWorker(null, DEFAULT_OPTIONS); bufferPoolSlice = new ByteBufferSlicePool(BufferAllocator.DIRECT_BYTE_BUFFER_ALLOCATOR, 17 * 1024, 17 * 1024 * 20); UndertowClient.getInstance().connect(portForwardURI, xnioWorker, xnioSsl, bufferPool, DEFAULT_OPTIONS); connection = connectFuture.getInterruptibly(); xnioWorker.shutdown();
private Http2Client(final ClassLoader classLoader) { ServiceLoader<ClientProvider> providers = ServiceLoader.load(ClientProvider.class, classLoader); final Map<String, ClientProvider> map = new HashMap<>(); for (ClientProvider provider : providers) { for (String scheme : provider.handlesSchemes()) { map.put(scheme, provider); } } this.clientProviders = Collections.unmodifiableMap(map); try { final Xnio xnio = Xnio.getInstance(); WORKER = xnio.createWorker(null, Http2Client.DEFAULT_OPTIONS); SSL = new UndertowXnioSsl(WORKER.getXnio(), OptionMap.EMPTY, BUFFER_POOL, createSSLContext()); } catch (Exception e) { logger.error("Exception: ", e); } }
public void start() { try { OptionMap.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); } }
/** * Schedules a task for future execution. If the execution is rejected because the worker is shutting * down then it is logged at debug level and the exception is not re-thrown * @param thread The IO thread * @param task The task to execute * @param timeout The timeout * @param timeUnit The time unit */ public static XnioExecutor.Key executeAfter(XnioIoThread thread, Runnable task, long timeout, TimeUnit timeUnit) { try { return thread.executeAfter(task, timeout, timeUnit); } catch (RejectedExecutionException e) { if(thread.getWorker().isShutdown()) { UndertowLogger.ROOT_LOGGER.debugf(e, "Failed to schedule task %s as worker is shutting down", task); //we just return a bogus key in this case return new XnioExecutor.Key() { @Override public boolean remove() { return false; } }; } else { throw e; } } } }
public void awaitReadable() throws IOException { Xnio.checkBlockingAllowed(); SelectorUtils.await((NioXnio)getWorker().getXnio(), sourceChannel, SelectionKey.OP_READ); }
@Override public void handleClose(org.jboss.remoting3.Endpoint closed, IOException exception) { endpoint.getXnioWorker().shutdown(); } });
public AcceptingChannel<SslConnection> createSslConnectionServer(final XnioWorker worker, final InetSocketAddress bindAddress, final ChannelListener<? super AcceptingChannel<SslConnection>> acceptListener, final OptionMap optionMap) throws IOException { final JsseAcceptingSslStreamConnection server = new JsseAcceptingSslStreamConnection(sslContext, worker.createStreamConnectionServer(bindAddress, null, optionMap), optionMap, bufferPool, bufferPool, optionMap.get(Options.SSL_STARTTLS, false)); if (acceptListener != null) server.getAcceptSetter().set(acceptListener); return server; } }
@Override public UndertowEndpoint connect(URI uri, XEndpointListener<? super UndertowEndpoint> listener) throws Exception { final int bufferSize = UndertowAtts.BUFFER_SIZE.get(config.attributes); final boolean directBuffers = UndertowAtts.DIRECT_BUFFERS.get(config.attributes); final ByteBufferPool pool = new DefaultByteBufferPool(directBuffers, bufferSize); final ConnectionBuilder builder = WebSocketClient.connectionBuilder(worker, pool, uri); if (uri.getScheme().equals("wss")) { final SSLContext sslContext = config.sslContextProvider.getSSLContext(); final ByteBufferPool sslBufferPool = new DefaultByteBufferPool(directBuffers, 17 * 1024); final XnioSsl ssl = new UndertowXnioSsl(worker.getXnio(), OptionMap.EMPTY, sslBufferPool, sslContext); builder.setSsl(ssl); } final WebSocketChannel channel = builder.connect().get(); return UndertowEndpoint.clientOf(scanner, channel, config, listener); }
@Override public void failed() { if (healthCheckFailed() == threshold) { // Remove using the executor task pool ioThread.getWorker().execute(new Runnable() { @Override public void run() { container.removeNode(Node.this, true); clearActivePing(); } }); } else { clearActivePing(); } } }, healthChecker, ioThread, bufferPool, container.getClient(), container.getXnioSsl(), OptionMap.EMPTY);
private void shutdownWorkers() { try { worker.shutdownNow(); } catch (Exception e) { logger.error("Error shutting down workers", e); } }
XnioWorker localWorker = worker; worker = null; localWorker.shutdown(); boolean interrupted = false; try { List<Runnable> tasks = localWorker.shutdownNow(); for (Runnable task : tasks) { IOLogger.ROOT_LOGGER.debugf("Worker was shut down forcibly. Submitting task %s to the management executor", task);
@Override protected void doStop() throws Exception { super.doStop(); if (endpoint.isWebSocket()) { endpoint.getComponent().unregisterEndpoint(endpoint.getHttpHandlerRegistrationInfo(), endpoint.getSslContext()); } if (worker != null && !worker.isShutdown()) { LOG.debug("Shutting down worker: {}", worker); worker.shutdown(); } }