Refine search
private XnioWorker createWorker() throws IOException { Xnio xnio = Xnio.getInstance(Undertow.class.getClassLoader()); return xnio.createWorker( OptionMap.builder().set(Options.THREAD_DAEMON, true).getMap()); }
fileSystemWatcher = Xnio.getInstance().createFileSystemWatcher("Watcher for " + base, OptionMap.EMPTY); fileSystemWatcher.watchPath(new File(base), new FileChangeCallback() { @Override
/** {@inheritDoc} */ public String getName() { return INSTANCE.getName(); } }
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.bufferPool = new DefaultByteBufferPool(false, 1024, -1, 2); }
public synchronized void start() { UndertowLogger.ROOT_LOGGER.debugf("starting undertow server %s", this); xnio = Xnio.getInstance(Undertow.class.getClassLoader()); channels = new ArrayList<>(); try { if (internalWorker) { 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) .getMap(); OptionMap serverOptions = OptionMap.builder() .set(UndertowOptions.NO_REQUEST_TIMEOUT, 60 * 1000) .addAll(this.serverOptions) 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);
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); xnioWorker.shutdown();
@Override public void start(StartContext startContext) throws StartException { //todo: this is a bit of a hack, as the proxy handler may be wrapped by a request controller handler for graceful shutdown ProxyHandler proxyHandler = (ProxyHandler) (this.proxyHandler.getValue() instanceof GlobalRequestControllerHandler ? ((GlobalRequestControllerHandler)this.proxyHandler.getValue()).getNext() : this.proxyHandler.getValue()); final LoadBalancingProxyClient client = (LoadBalancingProxyClient) proxyHandler.getProxyClient(); try { SSLContext sslContext = this.sslContext.getOptionalValue(); if (sslContext == null) { SecurityRealm securityRealm = this.securityRealm.getOptionalValue(); if (securityRealm != null) { sslContext = securityRealm.getSSLContext(); } } if (sslContext == null) { client.addHost(getUri(), instanceId, null, OptionMap.create(UndertowOptions.ENABLE_HTTP2, enableHttp2)); } else { OptionMap.Builder builder = OptionMap.builder(); builder.set(Options.USE_DIRECT_BUFFERS, true); OptionMap combined = builder.getMap(); XnioSsl xnioSsl = new UndertowXnioSsl(Xnio.getInstance(), combined, sslContext); client.addHost(getUri(), instanceId, xnioSsl, OptionMap.create(UndertowOptions.ENABLE_HTTP2, enableHttp2)); } } catch (URISyntaxException e) { throw new StartException(e); } }
sm.checkPermission(CREATE_ENDPOINT_PERM); final OptionMap modifiedOptionMap = OptionMap.builder().addAll(optionMap).set(Options.WORKER_NAME, endpointName == null ? "Remoting (anonymous)" : "Remoting \"" + endpointName + "\"").getMap(); final AtomicReference<Endpoint> endpointRef = new AtomicReference<Endpoint>(); final XnioWorker xnioWorker = xnio.createWorker(null, modifiedOptionMap, new Runnable() { public void run() { final Endpoint endpoint = endpointRef.getAndSet(null);
if (endpointCreationOptions != null && endpointCreationOptions.size() > 0) { if (! endpointCreationOptions.contains(Options.THREAD_DAEMON)) { endpointCreationOptions = OptionMap.builder().addAll(endpointCreationOptions).set(Options.THREAD_DAEMON, true).getMap(); endpointBuilder.buildXnioWorker(Xnio.getInstance()).populateFromOptions(endpointCreationOptions);
@Override public void bootUp() { try { xnio = Xnio.getInstance(UndertowNetwork.class.getClassLoader()); // abcdefgdgd1234566789(dddd) worker = createWorker(); socketOptions = createSocketOptions(); serverOptions = OptionMap.builder() .set(UndertowOptions.BUFFER_PIPELINED_DATA, true) .set(UndertowOptions.ALWAYS_SET_KEEP_ALIVE, false) .set(UndertowOptions.ALWAYS_SET_DATE, true) .set(UndertowOptions.RECORD_REQUEST_START_TIME, false) .set(UndertowOptions.NO_REQUEST_TIMEOUT, 60 * 1000) .set(UndertowOptions.ENABLE_STATISTICS, Act.conf().xioStatistics()) .getMap(); channels = new ArrayList<>(); } catch (Exception e) { throw E.unexpected(e, "Error booting up Undertow service: %s", e.getMessage()); } }
/** * Create a new {@link XnioEventLoopGroup} which creates a new {@link XnioWorker} by itself and use it for all * operations. Using the given number of Threads to handle the IO. * * @throws IOException */ public XnioEventLoopGroup(int numThreads) throws IOException { this(Xnio.getInstance().createWorker(OptionMap.create(Options.WORKER_IO_THREADS, numThreads))); }
int allWorkerCount = workers.asList().size(); final String name = context.getCurrentAddressValue(); final XnioWorker.Builder builder = Xnio.getInstance().createWorkerBuilder(); final OptionMap.Builder optionMapBuilder = OptionMap.builder(); optionMapBuilder.set((Option<Integer>) option, value.asInt()); } else if (attr.getType() == ModelType.LONG) { optionMapBuilder.set(option, value.asLong()); } else if (attr.getType() == ModelType.BOOLEAN) { optionMapBuilder.set(option, value.asBoolean());
/** * Create a new endpoint with the given configuration. This method (starting with 3.3) will use the class loader * of XNIO itself to construct the XNIO implementation. * * @param endpointName the name of the endpoint * @param optionMap the options to configure the endpoint * @return the new endpoint * @throws IOException if an error occurs */ public static Endpoint createEndpoint(final String endpointName, final OptionMap optionMap) throws IOException { return createEndpoint(endpointName, Xnio.getInstance(), optionMap); }
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); } }
private void deployReverseProxyRoutes(final DeploymentContext context) throws URISyntaxException, NoSuchAlgorithmException, NoSuchProviderException, KeyManagementException { var lastHandler = context.rootHandler(); val ssl = new UndertowXnioSsl( Xnio.getInstance(), OptionMap.EMPTY ); val options = isHttp2EnabledForProxy ? OptionMap.create(UndertowOptions.ENABLE_HTTP2, true) : OptionMap.EMPTY ; if ( !reverseRoutes.isEmpty() ) log.info( "Reverse Proxy rules:" ); for ( val rule : reverseRoutes ) { log.info( " > " + rule ); val target = URLMatcher.compile( rule.target() ); val proxyClient = createClientFor( rule, target, ssl, options ); lastHandler = new ProxyHandler( proxyClient, lastHandler ); } context.rootHandler( lastHandler ); }
/** * Construct a new XNIO worker. * * @param optionMap the options to use to configure the worker * @return the new worker * @throws IOException if the worker failed to be opened * @throws IllegalArgumentException if an option value is invalid for this worker */ public XnioWorker createWorker(OptionMap optionMap) throws IOException, IllegalArgumentException { return createWorker(null, optionMap); }
storePassword); log.config("Setting XNIO Provider : " + Xnio.getInstance() .getName()); Undertow.Builder server = Undertow.builder(); if (http2)
/** * @deprecated Use {@link #WorkerService(XnioWorker.Builder)} instead to allow setting of full range of options. */ public WorkerService(OptionMap optionMap) { this(Xnio.getInstance().createWorkerBuilder().populateFromOptions(optionMap)); }
@Override public FileSystemWatcher createFileSystemWatcher(String name, OptionMap options) { try { boolean daemonThread = options.get(Options.THREAD_DAEMON, true); return new WatchServiceFileSystemWatcher(name, daemonThread); } catch (LinkageError e) { //ignore } return super.createFileSystemWatcher(name, options); }
public synchronized void start() { UndertowLogger.ROOT_LOGGER.debugf("starting undertow server %s", this); xnio = Xnio.getInstance(Undertow.class.getClassLoader()); channels = new ArrayList<>(); try { if (internalWorker) { 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) .getMap(); OptionMap serverOptions = OptionMap.builder() .set(UndertowOptions.NO_REQUEST_TIMEOUT, 60 * 1000) .addAll(this.serverOptions) 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);