org.glassfish.grizzly.nio.NIOTransport Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2008, 2020 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package org.glassfish.grizzly.nio;
import java.io.IOException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.glassfish.grizzly.AbstractTransport;
import org.glassfish.grizzly.Connection;
import org.glassfish.grizzly.GracefulShutdownListener;
import org.glassfish.grizzly.Grizzly;
import org.glassfish.grizzly.GrizzlyFuture;
import org.glassfish.grizzly.SocketBinder;
import org.glassfish.grizzly.SocketConnectorHandler;
import org.glassfish.grizzly.StandaloneProcessor;
import org.glassfish.grizzly.Transport;
import org.glassfish.grizzly.TransportProbe;
import org.glassfish.grizzly.asyncqueue.AsyncQueueEnabledTransport;
import org.glassfish.grizzly.impl.FutureImpl;
import org.glassfish.grizzly.localization.LogMessages;
import org.glassfish.grizzly.nio.tmpselectors.TemporarySelectorIO;
import org.glassfish.grizzly.nio.tmpselectors.TemporarySelectorPool;
import org.glassfish.grizzly.nio.tmpselectors.TemporarySelectorsEnabledTransport;
import org.glassfish.grizzly.strategies.SameThreadIOStrategy;
import org.glassfish.grizzly.strategies.WorkerThreadIOStrategy;
import org.glassfish.grizzly.threadpool.AbstractThreadPool;
import org.glassfish.grizzly.threadpool.GrizzlyExecutorService;
import org.glassfish.grizzly.threadpool.ThreadPoolConfig;
import org.glassfish.grizzly.utils.Futures;
/**
*
* @author oleksiys
*/
public abstract class NIOTransport extends AbstractTransport
implements SocketBinder, SocketConnectorHandler, TemporarySelectorsEnabledTransport, AsyncQueueEnabledTransport {
public static final int DEFAULT_SERVER_SOCKET_SO_TIMEOUT = 0;
public static final boolean DEFAULT_REUSE_ADDRESS = true;
public static final int DEFAULT_CLIENT_SOCKET_SO_TIMEOUT = 0;
public static final int DEFAULT_CONNECTION_TIMEOUT = SocketConnectorHandler.DEFAULT_CONNECTION_TIMEOUT;
public static final int DEFAULT_SELECTOR_RUNNER_COUNT = -1;
public static final boolean DEFAULT_OPTIMIZED_FOR_MULTIPLEXING = false;
private static final Logger LOGGER = Grizzly.logger(NIOTransport.class);
protected SelectorHandler selectorHandler;
protected SelectionKeyHandler selectionKeyHandler;
/**
* The server socket time out
*/
int serverSocketSoTimeout = DEFAULT_SERVER_SOCKET_SO_TIMEOUT;
/**
* The socket reuseAddress
*/
boolean reuseAddress = DEFAULT_REUSE_ADDRESS;
/**
* The socket time out
*/
int clientSocketSoTimeout = DEFAULT_CLIENT_SOCKET_SO_TIMEOUT;
/**
* Default channel connection timeout
*/
int connectionTimeout = DEFAULT_CONNECTION_TIMEOUT;
protected ChannelConfigurator channelConfigurator;
private int selectorRunnersCount = DEFAULT_SELECTOR_RUNNER_COUNT;
private boolean optimizedForMultiplexing = DEFAULT_OPTIMIZED_FOR_MULTIPLEXING;
protected SelectorRunner[] selectorRunners;
protected NIOChannelDistributor nioChannelDistributor;
protected SelectorProvider selectorProvider = SelectorProvider.provider();
protected final TemporarySelectorIO temporarySelectorIO;
protected Set shutdownListeners;
/**
* Future to control graceful shutdown status
*/
protected FutureImpl shutdownFuture;
/**
* ExecutorService hosting shutdown listener threads.
*/
protected ExecutorService shutdownService;
public NIOTransport(final String name) {
super(name);
temporarySelectorIO = createTemporarySelectorIO();
}
@Override
public abstract void unbindAll();
@Override
public boolean addShutdownListener(final GracefulShutdownListener shutdownListener) {
final Lock lock = state.getStateLocker().writeLock();
lock.lock();
try {
final State stateNow = state.getState();
if (stateNow != State.STOPPING || stateNow != State.STOPPED) {
if (shutdownListeners == null) {
shutdownListeners = new HashSet<>();
}
return shutdownListeners.add(shutdownListener);
}
return false;
} finally {
lock.unlock();
}
}
@Override
public TemporarySelectorIO getTemporarySelectorIO() {
return temporarySelectorIO;
}
public SelectionKeyHandler getSelectionKeyHandler() {
return selectionKeyHandler;
}
public void setSelectionKeyHandler(final SelectionKeyHandler selectionKeyHandler) {
this.selectionKeyHandler = selectionKeyHandler;
notifyProbesConfigChanged(this);
}
public SelectorHandler getSelectorHandler() {
return selectorHandler;
}
public void setSelectorHandler(final SelectorHandler selectorHandler) {
this.selectorHandler = selectorHandler;
notifyProbesConfigChanged(this);
}
/**
* @return the configurator responsible for initial {@link SelectableChannel} configuration
*/
public ChannelConfigurator getChannelConfigurator() {
return channelConfigurator;
}
/**
* Sets the configurator responsible for initial {@link SelectableChannel} configuration.
*
* @param channelConfigurator {@link ChannelConfigurator}
*/
public void setChannelConfigurator(final ChannelConfigurator channelConfigurator) {
this.channelConfigurator = channelConfigurator;
notifyProbesConfigChanged(this);
}
/**
* @return the number of {@link SelectorRunner}s used for handling NIO events
*/
public int getSelectorRunnersCount() {
if (selectorRunnersCount <= 0) {
selectorRunnersCount = getDefaultSelectorRunnersCount();
}
return selectorRunnersCount;
}
/**
* Sets the number of {@link SelectorRunner}s used for handling NIO events.
*
* @param selectorRunnersCount
*/
public void setSelectorRunnersCount(final int selectorRunnersCount) {
if (selectorRunnersCount > 0) {
this.selectorRunnersCount = selectorRunnersCount;
if (kernelPoolConfig != null && kernelPoolConfig.getMaxPoolSize() < selectorRunnersCount) {
kernelPoolConfig.setCorePoolSize(selectorRunnersCount).setMaxPoolSize(selectorRunnersCount);
}
notifyProbesConfigChanged(this);
}
}
/**
* Get the {@link SelectorProvider} to be used by this transport.
*
* @return the {@link SelectorProvider} to be used by this transport.
*/
public SelectorProvider getSelectorProvider() {
return selectorProvider;
}
/**
* Set the {@link SelectorProvider} to be used by this transport.
*
* @param selectorProvider the {@link SelectorProvider}.
*/
public void setSelectorProvider(final SelectorProvider selectorProvider) {
this.selectorProvider = selectorProvider != null ? selectorProvider : SelectorProvider.provider();
}
/**
* Returns true, if NIOTransport is configured to use
* {@link org.glassfish.grizzly.asyncqueue.AsyncQueueWriter}, optimized to be used in connection multiplexing mode, or
* false otherwise.
*
* @return true, if NIOTransport is configured to use
* {@link org.glassfish.grizzly.asyncqueue.AsyncQueueWriter}, optimized to be used in connection multiplexing mode, or
* false otherwise.
*/
@SuppressWarnings("UnusedDeclaration")
public boolean isOptimizedForMultiplexing() {
return optimizedForMultiplexing;
}
/**
* Configures NIOTransport to be optimized for specific for the connection multiplexing usecase, when different
* threads will try to write data simultaneously.
*/
public void setOptimizedForMultiplexing(final boolean optimizedForMultiplexing) {
this.optimizedForMultiplexing = optimizedForMultiplexing;
getAsyncQueueIO().getWriter().setAllowDirectWrite(!optimizedForMultiplexing);
}
protected synchronized void startSelectorRunners() throws IOException {
selectorRunners = new SelectorRunner[selectorRunnersCount];
for (int i = 0; i < selectorRunnersCount; i++) {
final SelectorRunner runner = SelectorRunner.create(this);
runner.start();
selectorRunners[i] = runner;
}
}
protected synchronized void stopSelectorRunners() {
if (selectorRunners == null) {
return;
}
for (int i = 0; i < selectorRunners.length; i++) {
SelectorRunner runner = selectorRunners[i];
if (runner != null) {
runner.stop();
selectorRunners[i] = null;
}
}
selectorRunners = null;
}
public NIOChannelDistributor getNIOChannelDistributor() {
return nioChannelDistributor;
}
public void setNIOChannelDistributor(final NIOChannelDistributor nioChannelDistributor) {
this.nioChannelDistributor = nioChannelDistributor;
notifyProbesConfigChanged(this);
}
/**
* {@inheritDoc}
*/
@Override
public void notifyTransportError(final Throwable error) {
notifyProbesError(this, error);
}
protected SelectorRunner[] getSelectorRunners() {
return selectorRunners;
}
/**
* Notify registered {@link TransportProbe}s about the error.
*
* @param transport the Transport event occurred on.
*/
protected static void notifyProbesError(final NIOTransport transport, final Throwable error) {
final TransportProbe[] probes = transport.transportMonitoringConfig.getProbesUnsafe();
if (probes != null) {
for (TransportProbe probe : probes) {
probe.onErrorEvent(transport, error);
}
}
}
/**
* Notify registered {@link TransportProbe}s about the start event.
*
* @param transport the Transport event occurred on.
*/
protected static void notifyProbesStart(final NIOTransport transport) {
final TransportProbe[] probes = transport.transportMonitoringConfig.getProbesUnsafe();
if (probes != null) {
for (TransportProbe probe : probes) {
probe.onStartEvent(transport);
}
}
}
/**
* Notify registered {@link TransportProbe}s about the stop event.
*
* @param transport the Transport event occurred on.
*/
protected static void notifyProbesStop(final NIOTransport transport) {
final TransportProbe[] probes = transport.transportMonitoringConfig.getProbesUnsafe();
if (probes != null) {
for (TransportProbe probe : probes) {
probe.onStopEvent(transport);
}
}
}
/**
* Notify registered {@link TransportProbe}s about the pause event.
*
* @param transport the Transport event occurred on.
*/
protected static void notifyProbesPause(final NIOTransport transport) {
final TransportProbe[] probes = transport.transportMonitoringConfig.getProbesUnsafe();
if (probes != null) {
for (TransportProbe probe : probes) {
probe.onPauseEvent(transport);
}
}
}
/**
* Notify registered {@link TransportProbe}s about the resume event.
*
* @param transport the Transport event occurred on.
*/
protected static void notifyProbesResume(final NIOTransport transport) {
final TransportProbe[] probes = transport.transportMonitoringConfig.getProbesUnsafe();
if (probes != null) {
for (TransportProbe probe : probes) {
probe.onResumeEvent(transport);
}
}
}
/**
* Start TCPNIOTransport.
*
* The transport will be started only if its current state is {@link State#STOPPED}, otherwise the call will be ignored
* without exception thrown and the transport state will remain the same as it was before the method call.
*
* @throws java.io.IOException if an attempt was made to actually start which failed
*/
@Override
public void start() throws IOException {
final Lock lock = state.getStateLocker().writeLock();
lock.lock();
try {
State currentState = state.getState();
if (currentState != State.STOPPED) {
LOGGER.log(Level.WARNING, LogMessages.WARNING_GRIZZLY_TRANSPORT_NOT_STOP_STATE_EXCEPTION());
return;
}
state.setState(State.STARTING);
notifyProbesBeforeStart(this);
if (selectorProvider == null) {
selectorProvider = SelectorProvider.provider();
}
if (selectorHandler == null) {
selectorHandler = new DefaultSelectorHandler();
}
if (selectionKeyHandler == null) {
selectionKeyHandler = new DefaultSelectionKeyHandler();
}
if (processor == null && processorSelector == null) {
processor = new StandaloneProcessor();
}
final int selectorRunnersCnt = getSelectorRunnersCount();
if (nioChannelDistributor == null) {
nioChannelDistributor = new RoundRobinConnectionDistributor(this);
}
if (kernelPool == null) {
if (kernelPoolConfig == null) {
kernelPoolConfig = ThreadPoolConfig.defaultConfig().setCorePoolSize(selectorRunnersCnt).setMaxPoolSize(selectorRunnersCnt)
.setPoolName("grizzly-nio-kernel");
} else if (kernelPoolConfig.getMaxPoolSize() < selectorRunnersCnt) {
LOGGER.log(Level.INFO, "Adjusting kernel thread pool to max " + "size {0} to handle configured number of SelectorRunners",
selectorRunnersCnt);
kernelPoolConfig.setCorePoolSize(selectorRunnersCnt).setMaxPoolSize(selectorRunnersCnt);
}
kernelPoolConfig.setMemoryManager(memoryManager);
setKernelPool0(GrizzlyExecutorService.createInstance(kernelPoolConfig));
}
if (workerThreadPool == null) {
if (workerPoolConfig != null) {
if (getThreadPoolMonitoringConfig().hasProbes()) {
workerPoolConfig.getInitialMonitoringConfig().addProbes(getThreadPoolMonitoringConfig().getProbes());
}
workerPoolConfig.setMemoryManager(memoryManager);
setWorkerThreadPool0(GrizzlyExecutorService.createInstance(workerPoolConfig));
}
}
/*
* By default TemporarySelector pool size should be equal to the number of processing threads
*/
int selectorPoolSize = TemporarySelectorPool.DEFAULT_SELECTORS_COUNT;
if (workerThreadPool instanceof AbstractThreadPool) {
if (strategy instanceof SameThreadIOStrategy) {
selectorPoolSize = selectorRunnersCnt;
} else {
selectorPoolSize = Math.min(((AbstractThreadPool) workerThreadPool).getConfig().getMaxPoolSize(), selectorPoolSize);
}
}
if (strategy == null) {
strategy = WorkerThreadIOStrategy.getInstance();
}
temporarySelectorIO.setSelectorPool(new TemporarySelectorPool(selectorProvider, selectorPoolSize));
startSelectorRunners();
listen();
state.setState(State.STARTED);
notifyProbesStart(this);
} finally {
lock.unlock();
}
}
@Override
public GrizzlyFuture shutdown() {
return shutdown(-1, TimeUnit.MILLISECONDS);
}
/**
* {@inheritDoc}
*/
@Override
public GrizzlyFuture shutdown(final long gracePeriod, final TimeUnit timeUnit) {
final Lock lock = state.getStateLocker().writeLock();
lock.lock();
try {
final State stateNow = state.getState();
if (stateNow == State.STOPPING) {
// graceful shutdown in progress
return shutdownFuture;
} else if (stateNow == State.STOPPED) {
return Futures.createReadyFuture(this);
} else if (stateNow == State.PAUSED) {
resume();
}
state.setState(State.STOPPING);
unbindAll();
final GrizzlyFuture resultFuture;
if (shutdownListeners != null && !shutdownListeners.isEmpty()) {
shutdownFuture = Futures.createSafeFuture();
shutdownService = createShutdownExecutorService();
shutdownService.execute(new GracefulShutdownRunner(this, shutdownListeners, shutdownService, gracePeriod, timeUnit));
shutdownListeners = null;
resultFuture = shutdownFuture;
} else {
finalizeShutdown();
resultFuture = Futures.createReadyFuture(this);
}
return resultFuture;
} finally {
lock.unlock();
}
}
/**
* {@inheritDoc}
*/
@Override
public void shutdownNow() throws IOException {
final Lock lock = state.getStateLocker().writeLock();
lock.lock();
try {
final State stateNow = state.getState();
if (stateNow == State.STOPPED) {
return;
}
if (stateNow == State.PAUSED) {
// if Transport is paused - first we need to resume it
// so selectorrunners can perform the close phase
resume();
}
state.setState(State.STOPPING);
unbindAll();
finalizeShutdown();
} finally {
lock.unlock();
}
}
@Override
protected abstract void closeConnection(Connection connection) throws IOException;
protected abstract TemporarySelectorIO createTemporarySelectorIO();
protected abstract void listen();
protected int getDefaultSelectorRunnersCount() {
return Runtime.getRuntime().availableProcessors();
}
protected void finalizeShutdown() {
if (shutdownService != null && !shutdownService.isShutdown()) {
final boolean isInterrupted = Thread.currentThread().isInterrupted();
shutdownService.shutdownNow();
shutdownService = null;
if (!isInterrupted) {
// if we're in shutdown thread and prev status was "not-interrupted" -
// clear the interrupted flag, which might have been set
// when we shutdownNow() the shutdownService.
Thread.interrupted();
}
}
notifyProbesBeforeStop(this);
stopSelectorRunners();
if (workerThreadPool != null && managedWorkerPool) {
workerThreadPool.shutdown();
workerThreadPool = null;
}
if (kernelPool != null) {
kernelPool.shutdownNow();
kernelPool = null;
}
state.setState(State.STOPPED);
notifyProbesStop(this);
if (shutdownFuture != null) {
shutdownFuture.result(this);
shutdownFuture = null;
}
}
/**
* Pause UDPNIOTransport, so I/O events coming on its {@link org.glassfish.grizzly.nio.transport.UDPNIOConnection}s will
* not be processed. Use {@link #resume()} in order to resume UDPNIOTransport processing.
*
* The transport will be paused only if its current state is {@link org.glassfish.grizzly.Transport.State#STARTED},
* otherwise the call will be ignored without exception thrown and the transport state will remain the same as it was
* before the method call.
*/
@Override
public void pause() {
final Lock lock = state.getStateLocker().writeLock();
lock.lock();
try {
if (state.getState() != State.STARTED) {
LOGGER.log(Level.WARNING, LogMessages.WARNING_GRIZZLY_TRANSPORT_NOT_START_STATE_EXCEPTION());
return;
}
state.setState(State.PAUSING);
notifyProbesBeforePause(this);
state.setState(State.PAUSED);
notifyProbesPause(this);
} finally {
lock.unlock();
}
}
/**
* Resume UDPNIOTransport, which has been paused before using {@link #pause()}.
*
* The transport will be resumed only if its current state is {@link org.glassfish.grizzly.Transport.State#PAUSED},
* otherwise the call will be ignored without exception thrown and the transport state will remain the same as it was
* before the method call.
*/
@Override
public void resume() {
final Lock lock = state.getStateLocker().writeLock();
lock.lock();
try {
if (state.getState() != State.PAUSED) {
LOGGER.log(Level.WARNING, LogMessages.WARNING_GRIZZLY_TRANSPORT_NOT_PAUSE_STATE_EXCEPTION());
return;
}
state.setState(State.STARTING);
notifyProbesBeforeResume(this);
state.setState(State.STARTED);
notifyProbesResume(this);
} finally {
lock.unlock();
}
}
protected void configureNIOConnection(NIOConnection connection) {
connection.configureBlocking(isBlocking);
connection.configureStandalone(isStandalone);
connection.setProcessor(processor);
connection.setProcessorSelector(processorSelector);
connection.setReadTimeout(readTimeout, TimeUnit.MILLISECONDS);
connection.setWriteTimeout(writeTimeout, TimeUnit.MILLISECONDS);
if (connectionMonitoringConfig.hasProbes()) {
connection.setMonitoringProbes(connectionMonitoringConfig.getProbes());
}
}
public boolean isReuseAddress() {
return reuseAddress;
}
public void setReuseAddress(final boolean reuseAddress) {
this.reuseAddress = reuseAddress;
notifyProbesConfigChanged(this);
}
public int getClientSocketSoTimeout() {
return clientSocketSoTimeout;
}
@SuppressWarnings({ "UnusedDeclaration" })
public void setClientSocketSoTimeout(final int socketTimeout) {
if (socketTimeout < 0) {
throw new IllegalArgumentException("socketTimeout can't be negative value");
}
this.clientSocketSoTimeout = socketTimeout;
notifyProbesConfigChanged(this);
}
public int getConnectionTimeout() {
return connectionTimeout;
}
@SuppressWarnings({ "UnusedDeclaration" })
public void setConnectionTimeout(final int connectionTimeout) {
this.connectionTimeout = connectionTimeout;
notifyProbesConfigChanged(this);
}
public int getServerSocketSoTimeout() {
return serverSocketSoTimeout;
}
@SuppressWarnings({ "UnusedDeclaration" })
public void setServerSocketSoTimeout(final int serverSocketSoTimeout) {
if (serverSocketSoTimeout < 0) {
throw new IllegalArgumentException("socketTimeout can't be negative value");
}
this.serverSocketSoTimeout = serverSocketSoTimeout;
notifyProbesConfigChanged(this);
}
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);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy