Package org.apache.mina.core.polling

Class AbstractPollingIoAcceptor<S extends AbstractIoSession,​H>

  • Type Parameters:
    H - The type of IoHandler
    S - The type of IoSession
    All Implemented Interfaces:
    IoAcceptor, IoService
    Direct Known Subclasses:
    AprSocketAcceptor, NioSocketAcceptor
    public abstract class AbstractPollingIoAcceptor<S extends AbstractIoSession,​H>
extends AbstractIoAcceptor
    A base class for implementing transport using a polling strategy. The underlying sockets will be checked in an active loop and woke up when an socket needed to be processed. This class handle the logic behind binding, accepting and disposing the server sockets. An Executor will be used for running client accepting and an AbstractPollingIoProcessor will be used for processing client I/O operations like reading, writing and closing. All the low level methods for binding, accepting, closing need to be provided by the subclassing implementation.
    See Also:
    for a example of implementation

    • Field Detail

      • lock

        private final java.util.concurrent.Semaphore lock
        A lock used to protect the selector to be waked up before it's created

      • createdProcessor

        private final boolean createdProcessor

      • boundHandles

        private final java.util.Map<java.net.SocketAddress,​H> boundHandles

      • selectable

        private volatile boolean selectable
        A flag set when the acceptor has been created and initialized

      • reuseAddress

        protected boolean reuseAddress

      • backlog

        protected int backlog
        Define the number of socket that can wait to be accepted. Default to 50 (as in the SocketServer default).

    • Constructor Detail

      • AbstractPollingIoAcceptor

        protected AbstractPollingIoAcceptor​(IoSessionConfig sessionConfig,
                                    java.lang.Class<? extends IoProcessor<S>> processorClass,
                                    int processorCount)
        Constructor for AbstractPollingIoAcceptor. You need to provide a default session configuration, a class of IoProcessor which will be instantiated in a SimpleIoProcessorPool for using multiple thread for better scaling in multiprocessor systems.
        Parameters:
        sessionConfig - the default configuration for the managed IoSession
        processorClass - a Class of IoProcessor for the associated IoSession type.
        processorCount - the amount of processor to instantiate for the pool
        See Also:
        SimpleIoProcessorPool

      • AbstractPollingIoAcceptor

        protected AbstractPollingIoAcceptor​(IoSessionConfig sessionConfig,
                                    java.lang.Class<? extends IoProcessor<S>> processorClass,
                                    int processorCount,
                                    java.nio.channels.spi.SelectorProvider selectorProvider)
        Constructor for AbstractPollingIoAcceptor. You need to provide a default session configuration, a class of IoProcessor which will be instantiated in a SimpleIoProcessorPool for using multiple thread for better scaling in multiprocessor systems.
        Parameters:
        sessionConfig - the default configuration for the managed IoSession
        processorClass - a Class of IoProcessor for the associated IoSession type.
        processorCount - the amount of processor to instantiate for the pool
        selectorProvider - The SelectorProvider to use
        See Also:
        SimpleIoProcessorPool

      • AbstractPollingIoAcceptor

        protected AbstractPollingIoAcceptor​(IoSessionConfig sessionConfig,
                                    java.util.concurrent.Executor executor,
                                    IoProcessor<S> processor)
        Constructor for AbstractPollingIoAcceptor. You need to provide a default session configuration and an Executor for handling I/O events. If a null Executor is provided, a default one will be created using Executors.newCachedThreadPool().
        Parameters:
        sessionConfig - the default configuration for the managed IoSession
        executor - the Executor used for handling asynchronous execution of I/O events. Can be null.
        processor - the IoProcessor for processing the IoSession of this transport, triggering events to the bound IoHandler and processing the chains of IoFilter
        See Also:
        AbstractIoService(IoSessionConfig, Executor)

      • AbstractPollingIoAcceptor

        private AbstractPollingIoAcceptor​(IoSessionConfig sessionConfig,
                                  java.util.concurrent.Executor executor,
                                  IoProcessor<S> processor,
                                  boolean createdProcessor,
                                  java.nio.channels.spi.SelectorProvider selectorProvider)
        Constructor for AbstractPollingIoAcceptor. You need to provide a default session configuration and an Executor for handling I/O events. If a null Executor is provided, a default one will be created using Executors.newCachedThreadPool().
        Parameters:
        sessionConfig - the default configuration for the managed IoSession
        executor - the Executor used for handling asynchronous execution of I/O events. Can be null.
        processor - the IoProcessor for processing the IoSession of this transport, triggering events to the bound IoHandler and processing the chains of IoFilter
        createdProcessor - tagging the processor as automatically created, so it will be automatically disposed
        See Also:
        #AbstractIoService(IoSessionConfig, Executor)

    • Method Detail

      • init

        protected abstract void init()
                      throws java.lang.Exception
        Initialize the polling system, will be called at construction time.
        Throws:
        java.lang.Exception - any exception thrown by the underlying system calls

      • init

        protected abstract void init​(java.nio.channels.spi.SelectorProvider selectorProvider)
                      throws java.lang.Exception
        Initialize the polling system, will be called at construction time.
        Parameters:
        selectorProvider - The Selector Provider that will be used by this polling acceptor
        Throws:
        java.lang.Exception - any exception thrown by the underlying system calls

      • destroy

        protected abstract void destroy()
                         throws java.lang.Exception
        Destroy the polling system, will be called when this IoAcceptor implementation will be disposed.
        Throws:
        java.lang.Exception - any exception thrown by the underlying systems calls

      • select

        protected abstract int select()
                       throws java.lang.Exception
        Check for acceptable connections, interrupt when at least a server is ready for accepting. All the ready server socket descriptors need to be returned by selectedHandles()
        Returns:
        The number of sockets having got incoming client
        Throws:
        java.lang.Exception - any exception thrown by the underlying systems calls

      • wakeup

        protected abstract void wakeup()
        Interrupt the select() method. Used when the poll set need to be modified.

      • selectedHandles

        protected abstract java.util.Iterator<H> selectedHandles()
        Iterator for the set of server sockets found with acceptable incoming connections during the last select() call.
        Returns:
        the list of server handles ready

      • open

        protected abstract H open​(java.net.SocketAddress localAddress)
                   throws java.lang.Exception
        Open a server socket for a given local address.
        Parameters:
        localAddress - the associated local address
        Returns:
        the opened server socket
        Throws:
        java.lang.Exception - any exception thrown by the underlying systems calls

      • localAddress

        protected abstract java.net.SocketAddress localAddress​(H handle)
                                                throws java.lang.Exception
        Get the local address associated with a given server socket
        Parameters:
        handle - the server socket
        Returns:
        the local SocketAddress associated with this handle
        Throws:
        java.lang.Exception - any exception thrown by the underlying systems calls

      • accept

        protected abstract S accept​(IoProcessor<S> processor,
                            H handle)
                     throws java.lang.Exception
        Accept a client connection for a server socket and return a new IoSession associated with the given IoProcessor
        Parameters:
        processor - the IoProcessor to associate with the IoSession
        handle - the server handle
        Returns:
        the created IoSession
        Throws:
        java.lang.Exception - any exception thrown by the underlying systems calls

      • close

        protected abstract void close​(H handle)
                       throws java.lang.Exception
        Close a server socket.
        Parameters:
        handle - the server socket
        Throws:
        java.lang.Exception - any exception thrown by the underlying systems calls

      • dispose0

        protected void dispose0()
                 throws java.lang.Exception
        Implement this method to release any acquired resources. This method is invoked only once by AbstractIoService.dispose().
        Specified by:
        dispose0 in class AbstractIoService
        Throws:
        java.lang.Exception - If the dispose failed

      • bindRequestAdded

        protected void bindRequestAdded()
        Invoked when a bind request has been registered for processing. The default implementation does nothing.

      • bindInternal

        protected final java.util.Set<java.net.SocketAddress> bindInternal​(java.util.List<? extends java.net.SocketAddress> localAddresses)
                                                            throws java.lang.Exception
        Starts the acceptor, and register the given addresses
        Specified by:
        bindInternal in class AbstractIoAcceptor
        Parameters:
        localAddresses - The address to bind to
        Returns:
        the Set of the local addresses which is bound actually
        Throws:
        java.lang.Exception - If the bind failed

      • startupAcceptor

        private void startupAcceptor()
                      throws java.lang.InterruptedException
        This method is called by the doBind() and doUnbind() methods. If the acceptor is null, the acceptor object will be created and kicked off by the executor. If the acceptor object is null, probably already created and this class is now working, then nothing will happen and the method will just return.
        Throws:
        java.lang.InterruptedException

      • unbind0

        protected final void unbind0​(java.util.List<? extends java.net.SocketAddress> localAddresses)
                      throws java.lang.Exception
        Implement this method to perform the actual unbind operation.
        Specified by:
        unbind0 in class AbstractIoAcceptor
        Parameters:
        localAddresses - The address to unbind from
        Throws:
        java.lang.Exception - If the unbind failed

      • processHandles

        protected void processHandles​(java.util.Iterator<H> handles)
                       throws java.lang.Exception
        Handles new incoming connections by accepting the connections and creating new sessions for them.
        Parameters:
        handles - the connection handles to accept and create new sessions for
        Throws:
        java.lang.Exception - on errors

      • hasUnbindings

        protected boolean hasUnbindings()
        Tells whether there are pending unbindings.
        Returns:
        true if there are any unbindings pending; false otherwise

      • handleUnbound

        protected void handleUnbound​(java.util.Collection<AbstractIoAcceptor.AcceptorOperationFuture> unboundFutures)
                      throws java.lang.Exception
        Processes the futures for executed unbindings, marking all futures as done.
        Parameters:
        unboundFutures - describing the unbindings
        Throws:
        java.lang.Exception - on errors

      • newSession

        public final IoSession newSession​(java.net.SocketAddress remoteAddress,
                                  java.net.SocketAddress localAddress)
        (Optional) Returns an IoSession that is bound to the specified localAddress and the specified remoteAddress which reuses the local address that is already bound by this service.

        This operation is optional. Please throw UnsupportedOperationException if the transport type doesn't support this operation. This operation is usually implemented for connectionless transport types.

        Parameters:
        remoteAddress - The remote address bound to the service
        localAddress - The local address the session will be bound to
        Returns:
        The session bound to the the given localAddress and remote address

      • getBacklog

        public int getBacklog()
        Returns:
        the backLog

      • setBacklog

        public void setBacklog​(int backlog)
        Sets the Backlog parameter
        Parameters:
        backlog - the backlog variable

      • isReuseAddress

        public boolean isReuseAddress()
        Returns:
        the flag that sets the reuseAddress information

      • setReuseAddress

        public void setReuseAddress​(boolean reuseAddress)
        Set the Reuse Address flag
        Parameters:
        reuseAddress - The flag to set

      • getSessionConfig

        public SocketSessionConfig getSessionConfig()
        Returns:
        the default configuration of the new IoSessions created by this service.