transport.setIOStrategy(ioStrategy); if (workerConfig != null) { transport.setWorkerThreadPoolConfig(workerConfig.copy()); transport.setKernelThreadPoolConfig(kernelConfig.copy()); transport.setSelectorProvider(selectorProvider); transport.setSelectorHandler(selectorHandler); transport.setSelectionKeyHandler(selectionKeyHandler); transport.setMemoryManager(memoryManager); transport.setAttributeBuilder(attributeBuilder); transport.setSelectorRunnersCount(selectorRunnerCount); transport.setNIOChannelDistributor(nioChannelDistributor); transport.setProcessor(processor); transport.setProcessorSelector(processorSelector); transport.setClientSocketSoTimeout(clientSocketSoTimeout); transport.setConnectionTimeout(connectionTimeout); transport.setReadTimeout(readTimeout, TimeUnit.MILLISECONDS); transport.setWriteTimeout(writeTimeout, TimeUnit.MILLISECONDS); transport.setReadBufferSize(readBufferSize); transport.setWriteBufferSize(writeBufferSize); transport.setReuseAddress(reuseAddress); transport.setOptimizedForMultiplexing(isOptimizedForMultiplexing()); transport.getAsyncQueueIO() .getWriter() .setMaxPendingBytesPerConnection(
public void detachSelectorRunner() throws IOException { final SelectorRunner selectorRunnerLocal = this.selectorRunner; this.selectionKey = null; this.selectorRunner = null; if (selectorRunnerLocal != null) { transport.getSelectorHandler().deregisterChannel(selectorRunnerLocal, channel); } }
@Override public MemoryManager<?> getMemoryManager() { return transport.getMemoryManager(); }
protected <T extends NIOTransport> T configureDefaultThreadPoolConfigs( final T transport) { transport.setKernelThreadPoolConfig(ThreadPoolConfig.defaultConfig()); transport.setWorkerThreadPoolConfig(ThreadPoolConfig.defaultConfig()); return transport; }
if (LOGGER.isLoggable(Level.WARNING)) { LOGGER.log(Level.WARNING, LogMessages.WARNING_GRIZZLY_GRACEFULSHUTDOWN_MSG( transport.getName() + '[' + Integer.toHexString(hashCode()) + ']', gracePeriod, timeUnit)); if (LOGGER.isLoggable(Level.WARNING)) { LOGGER.log(Level.WARNING, LogMessages.WARNING_GRIZZLY_GRACEFULSHUTDOWN_EXCEEDED( transport.getName() + '[' + Integer.toHexString(hashCode()) + ']')); LOGGER.warning(LogMessages.WARNING_GRIZZLY_GRACEFULSHUTDOWN_INTERRUPTED()); final Lock lock = transport.getState().getStateLocker().writeLock(); lock.lock(); transport.finalizeShutdown(); lock.unlock();
public void attachToSelectorRunner(final SelectorRunner selectorRunner) throws IOException { detachSelectorRunner(); final SelectorHandler selectorHandler = transport.getSelectorHandler(); final FutureImpl<RegisterChannelResult> future = Futures.createSafeFuture(); selectorHandler.registerChannelAsync( selectorRunner, channel, 0, this, Futures.toCompletionHandler(future)); try { final RegisterChannelResult result = future.get(readTimeoutMillis, TimeUnit.MILLISECONDS); this.selectorRunner = selectorRunner; this.selectionKey = result.getSelectionKey(); } catch (InterruptedException | TimeoutException e) { throw new IOException("", e); } catch (ExecutionException e) { throw new IOException("", e.getCause()); } }
@Test public void testConnectorHandlerConnectAndWrite() throws Exception { LOGGER.log(Level.INFO, "Running: testConnectorHandlerConnectAndWrite ({0})", transport.getName()); transport.bind(PORT); transport.start(); Futures.createSafeFuture(); transport.connect( new InetSocketAddress("localhost", PORT), Futures.toCompletionHandler( connectFuture, new EmptyCompletionHandler<Connection>() { connection = connectFuture.get(10, TimeUnit.SECONDS); assertTrue(connection != null); transport.shutdownNow();
transport.setMemoryManager( new ByteBufferManager(true, AbstractMemoryManager.DEFAULT_MAX_BUFFER_SIZE, ByteBufferManager.DEFAULT_SMALL_BUFFER_SIZE)); transport.setSelectorRunnersCount(Integer.parseInt(transportConfig.getAcceptorThreads())); transport.setReadBufferSize(readSize); transport.setWriteBufferSize(writeSize); transport.getKernelThreadPoolConfig().setPoolName(networkListener.getName() + "-kernel"); transport.setIOStrategy(loadIOStrategy(transportConfig.getIOStrategy())); transport.setNIOChannelDistributor( new RoundRobinConnectionDistributor( transport,
@Test public void testWorkerThreadPoolConfiguration2() throws Exception { LOGGER.log(Level.INFO, "Running: testWorkerThreadPoolConfiguration2 ({0})", transport.getName()); ThreadPoolConfig config = ThreadPoolConfig.defaultConfig(); config.setCorePoolSize(1); config.setMaxPoolSize(1); config.setPoolName("custom"); transport.setWorkerThreadPoolConfig(config); transport.setIOStrategy(SameThreadIOStrategy.getInstance()); assertNull(transport.getWorkerThreadPoolConfig()); assertNull(transport.getWorkerThreadPool()); }
@Override protected void configureTransport(final NetworkListener networkListener, final Transport transportConfig, final FilterChainBuilder filterChainBuilder) { transport = configureDefaultThreadPoolConfigs( TCPNIOTransportBuilder.newInstance().build()); final int acceptorThreads = transportConfig != null ? Integer.parseInt(transportConfig.getAcceptorThreads()) : Transport.ACCEPTOR_THREADS; transport.setSelectorRunnersCount(acceptorThreads); transport.getKernelThreadPoolConfig().setPoolName(networkListener.getName() + "-kernel"); if (acceptorThreads > 0) { transport.getKernelThreadPoolConfig() .setCorePoolSize(acceptorThreads) .setMaxPoolSize(acceptorThreads); } rootFilterChain = FilterChainBuilder.stateless().build(); transport.setProcessor(rootFilterChain); transport.setIOStrategy(SameThreadIOStrategy.getInstance()); }
@Override public Thread newThread(Runnable r) { final Thread newThread = new DefaultWorkerThread( transport.getAttributeBuilder(), getName() + '-' + threadCounter.getAndIncrement(), null, r); newThread.setDaemon(true); return newThread; } });
protected ExecutorService createShutdownExecutorService() { final String baseThreadIdentifier = this.getName() + '[' + Integer.toHexString(this.hashCode()) + "]-Shutdown-Thread"; final ThreadFactory factory = new ThreadFactory() { private int counter; @Override public Thread newThread(Runnable r) { Thread t = new Thread(r, baseThreadIdentifier + "(" + counter++ + ')'); t.setDaemon(true); return t; } }; return Executors.newFixedThreadPool(2, factory); } }
@Test public void testReadWriteTimeout() throws Exception { LOGGER.log(Level.INFO, "Running: testReadWriteTimeout ({0})", transport.getName()); assertEquals(30, transport.getWriteTimeout(TimeUnit.SECONDS)); assertEquals(30, transport.getReadTimeout(TimeUnit.SECONDS)); transport.setReadTimeout(45, TimeUnit.MINUTES); assertEquals(TimeUnit.MILLISECONDS.convert(45, TimeUnit.MINUTES), transport.getReadTimeout(TimeUnit.MILLISECONDS)); assertEquals(30, transport.getWriteTimeout(TimeUnit.SECONDS)); transport.setReadTimeout(-5, TimeUnit.SECONDS); assertEquals(-1, transport.getReadTimeout(TimeUnit.MILLISECONDS)); transport.setReadTimeout(0, TimeUnit.SECONDS); assertEquals(-1, transport.getReadTimeout(TimeUnit.MILLISECONDS)); }
@Test public void testStartStop() throws IOException { LOGGER.log(Level.INFO, "Running: testStartStop ({0})", transport.getName()); try { transport.bind(PORT); transport.start(); } finally { transport.shutdownNow(); } }
@Override public void configure(final ServiceLocator habitat, final NetworkListener networkListener) throws IOException { setName(networkListener.getName()); setAddress(InetAddress.getByName(networkListener.getAddress())); setPort(Integer.parseInt(networkListener.getPort())); final FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless(); configureTransport(networkListener, networkListener.findTransport(), filterChainBuilder); configureProtocol(habitat, networkListener, networkListener.findProtocol(), filterChainBuilder); configureThreadPool(habitat, networkListener, networkListener.findThreadPool()); rootFilterChain = filterChainBuilder.build(); transport.setProcessor(rootFilterChain); }
@Override protected void configureThreadPool(final ServiceLocator habitat, final NetworkListener networkListener, final ThreadPool threadPool) { // we don't need worker thread pool transport.setWorkerThreadPoolConfig(null); } }
protected void rebuildSubTree() { final MemoryManager memoryManager = transport.getMemoryManager(); if (currentMemoryManager != memoryManager) { if (currentMemoryManager != null) { final ExecutorService executorService = transport.getWorkerThreadPool(); final GrizzlyExecutorService threadPool; if (executorService instanceof GrizzlyExecutorService) { threadPool = (GrizzlyExecutorService) transport.getWorkerThreadPool(); } else { threadPool = null;
if (LOGGER.isLoggable(Level.WARNING)) { LOGGER.log(Level.WARNING, LogMessages.WARNING_GRIZZLY_GRACEFULSHUTDOWN_MSG( transport.getName() + '[' + Integer.toHexString(hashCode()) + ']', gracePeriod, timeUnit)); if (LOGGER.isLoggable(Level.WARNING)) { LOGGER.log(Level.WARNING, LogMessages.WARNING_GRIZZLY_GRACEFULSHUTDOWN_EXCEEDED( transport.getName() + '[' + Integer.toHexString(hashCode()) + ']')); LOGGER.warning(LogMessages.WARNING_GRIZZLY_GRACEFULSHUTDOWN_INTERRUPTED()); final Lock lock = transport.getState().getStateLocker().writeLock(); lock.lock(); transport.finalizeShutdown(); lock.unlock();
public void attachToSelectorRunner(final SelectorRunner selectorRunner) throws IOException { detachSelectorRunner(); final SelectorHandler selectorHandler = transport.getSelectorHandler(); final FutureImpl<RegisterChannelResult> future = Futures.createSafeFuture(); selectorHandler.registerChannelAsync( selectorRunner, channel, 0, this, Futures.toCompletionHandler(future)); try { final RegisterChannelResult result = future.get(readTimeoutMillis, TimeUnit.MILLISECONDS); this.selectorRunner = selectorRunner; this.selectionKey = result.getSelectionKey(); } catch (InterruptedException | TimeoutException e) { throw new IOException("", e); } catch (ExecutionException e) { throw new IOException("", e.getCause()); } }
@Test public void testSeveralPacketsAsyncReadWriteEcho() throws Exception { LOGGER.log(Level.INFO, "Running: testSeveralPacketsAsyncReadWriteEcho ({0})", transport.getName()); filterChainBuilder.add(new EchoFilter()); transport.setProcessor(filterChainBuilder.build()); transport.setReadBufferSize(2048); transport.setWriteBufferSize(2048); transport.bind(PORT); transport.start(); Futures.createSafeFuture(); transport.connect( new InetSocketAddress("localhost", PORT), Futures.toCompletionHandler( connectFuture, new EmptyCompletionHandler<Connection>() { @Override connection = connectFuture.get(10, TimeUnit.SECONDS); assertTrue(connection != null); transport.shutdownNow();