Package org.apache.mina.core.polling

Class AbstractPollingIoProcessor<S extends AbstractIoSession>

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private DefaultIoFuture disposalFuture  
      private java.lang.Object disposalLock  
      private boolean disposed  
      private boolean disposing  
      private java.util.concurrent.Executor executor
      The executor to use when we need to start the inner Processor
      private java.util.Queue<S> flushingSessions
      A queue used to store the sessions to be flushed
      private long lastIdleCheckTime  
      private static org.slf4j.Logger LOG
      A logger for this class
      private java.util.Queue<S> newSessions
      A Session queue containing the newly created sessions
      private java.util.concurrent.atomic.AtomicReference<AbstractPollingIoProcessor.Processor> processorRef
      The processor thread : it handles the incoming messages
      private java.util.Queue<S> removingSessions
      A queue used to store the sessions to be removed
      private static long SELECT_TIMEOUT
      A timeout used for the select, as we need to get out to deal with idle sessions
      private static java.util.concurrent.ConcurrentHashMap<java.lang.Class<?>,​java.util.concurrent.atomic.AtomicInteger> threadIds
      A map containing the last Thread ID for each class
      private java.lang.String threadName
      This IoProcessor instance name
      private java.util.Queue<S> trafficControllingSessions
      A queue used to store the sessions which have a trafficControl to be updated
      protected java.util.concurrent.atomic.AtomicBoolean wakeupCalled  

    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      void add​(S session)
      Adds the specified session to the I/O processor so that the I/O processor starts to perform any I/O operations related with the session.
      protected abstract java.util.Iterator<S> allSessions()
      Get an Iterator for the list of IoSession polled by this IoProcessor
      protected abstract int allSessionsCount()
      Get the number of IoSession polled by this IoProcessor
      protected abstract void destroy​(S session)
      Destroy the underlying client socket handle
      void dispose()
      Releases any resources allocated by this processor.
      protected abstract void doDispose()
      Dispose the resources used by this IoProcessor for polling the client connections.
      void flush​(S session)
      Flushes the internal write request queue of the specified session.
      protected abstract SessionState getState​(S session)
      Get the state of a session (One of OPENING, OPEN, CLOSING)
      protected abstract void init​(S session)
      Initialize the polling of a session.
      protected abstract boolean isBrokenConnection()
      Check that the select() has not exited immediately just because of a broken connection.
      boolean isDisposed()
      boolean isDisposing()
      protected abstract boolean isInterestedInRead​(S session)
      Tells if this session is registered for reading
      protected abstract boolean isInterestedInWrite​(S session)
      Tells if this session is registered for writing
      protected abstract boolean isReadable​(S session)
      Tells if the session ready for reading
      protected abstract boolean isSelectorEmpty()
      Say if the list of IoSession polled by this IoProcessor is empty
      protected abstract boolean isWritable​(S session)
      Tells if the session ready for writing
      private java.lang.String nextThreadName()
      Compute the thread ID for this class instance.
      private void read​(S session)  
      protected abstract int read​(S session, IoBuffer buf)
      Reads a sequence of bytes from a IoSession into the given IoBuffer.
      protected abstract void registerNewSelector()
      In the case we are using the java select() method, this method is used to trash the buggy selector and create a new one, registring all the sockets on it.
      void remove​(S session)
      Removes and closes the specified session from the I/O processor so that the I/O processor closes the connection associated with the session and releases any other related resources.
      private void scheduleRemove​(S session)  
      protected abstract int select()
      poll those sessions forever
      protected abstract int select​(long timeout)
      poll those sessions for the given timeout
      protected abstract java.util.Iterator<S> selectedSessions()
      Get an Iterator for the list of IoSession found selected by the last call of select(long)
      protected abstract void setInterestedInRead​(S session, boolean isInterested)
      Set the session to be informed when a read event should be processed
      protected abstract void setInterestedInWrite​(S session, boolean isInterested)
      Set the session to be informed when a write event should be processed
      private void startupProcessor()
      Starts the inner Processor, asking the executor to pick a thread in its pool.
      protected abstract int transferFile​(S session, FileRegion region, int length)
      Write a part of a file to a IoSession, if the underlying API isn't supporting system calls like sendfile(), you can throw a UnsupportedOperationException so the file will be send using usual write(AbstractIoSession, IoBuffer, int) call.
      void updateTrafficControl​(S session)
      Controls the traffic of the specified session depending of the IoSession.isReadSuspended() and IoSession.isWriteSuspended() flags
      void updateTrafficMask​(S session)
      Updates the traffic mask for a given session
      protected abstract void wakeup()
      Interrupt the select(long) call.
      protected abstract int write​(S session, IoBuffer buf, int length)
      Write a sequence of bytes to a IoSession, means to be called when a session was found ready for writing.
      void write​(S session, WriteRequest writeRequest)
      Writes the WriteRequest for the specified session.

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Field Detail

      • LOG

        private static final org.slf4j.Logger LOG
        A logger for this class

      • SELECT_TIMEOUT

        private static final long SELECT_TIMEOUT
        A timeout used for the select, as we need to get out to deal with idle sessions
        See Also:
        Constant Field Values

      • threadIds

        private static final java.util.concurrent.ConcurrentHashMap<java.lang.Class<?>,​java.util.concurrent.atomic.AtomicInteger> threadIds
        A map containing the last Thread ID for each class

      • threadName

        private final java.lang.String threadName
        This IoProcessor instance name

      • executor

        private final java.util.concurrent.Executor executor
        The executor to use when we need to start the inner Processor

      • newSessions

        private final java.util.Queue<S extends AbstractIoSession> newSessions
        A Session queue containing the newly created sessions

      • removingSessions

        private final java.util.Queue<S extends AbstractIoSession> removingSessions
        A queue used to store the sessions to be removed

      • flushingSessions

        private final java.util.Queue<S extends AbstractIoSession> flushingSessions
        A queue used to store the sessions to be flushed

      • trafficControllingSessions

        private final java.util.Queue<S extends AbstractIoSession> trafficControllingSessions
        A queue used to store the sessions which have a trafficControl to be updated

      • processorRef

        private final java.util.concurrent.atomic.AtomicReference<AbstractPollingIoProcessor.Processor> processorRef
        The processor thread : it handles the incoming messages

      • lastIdleCheckTime

        private long lastIdleCheckTime

      • disposalLock

        private final java.lang.Object disposalLock

      • disposing

        private volatile boolean disposing

      • disposed

        private volatile boolean disposed

      • wakeupCalled

        protected java.util.concurrent.atomic.AtomicBoolean wakeupCalled

    • Constructor Detail

      • AbstractPollingIoProcessor

        protected AbstractPollingIoProcessor​(java.util.concurrent.Executor executor)
        Create an AbstractPollingIoProcessor with the given Executor for handling I/Os events.
        Parameters:
        executor - the Executor for handling I/O events

    • Method Detail

      • nextThreadName

        private java.lang.String nextThreadName()
        Compute the thread ID for this class instance. As we may have different classes, we store the last ID number into a Map associating the class name to the last assigned ID.
        Returns:
        a name for the current thread, based on the class name and an incremental value, starting at 1.

      • isDisposed

        public final boolean isDisposed()
        Specified by:
        isDisposed in interface IoProcessor<S extends AbstractIoSession>
        Returns:
        true if and if only all resources of this processor have been disposed.

      • dispose

        public final void dispose()
        Releases any resources allocated by this processor. Please note that the resources might not be released as long as there are any sessions managed by this processor. Most implementations will close all sessions immediately and release the related resources.
        Specified by:
        dispose in interface IoProcessor<S extends AbstractIoSession>

      • doDispose

        protected abstract void doDispose()
                           throws java.lang.Exception
        Dispose the resources used by this IoProcessor for polling the client connections. The implementing class doDispose method will be called.
        Throws:
        java.lang.Exception - if some low level IO error occurs

      • select

        protected abstract int select​(long timeout)
                       throws java.lang.Exception
        poll those sessions for the given timeout
        Parameters:
        timeout - milliseconds before the call timeout if no event appear
        Returns:
        The number of session ready for read or for write
        Throws:
        java.lang.Exception - if some low level IO error occurs

      • select

        protected abstract int select()
                       throws java.lang.Exception
        poll those sessions forever
        Returns:
        The number of session ready for read or for write
        Throws:
        java.lang.Exception - if some low level IO error occurs

      • isSelectorEmpty

        protected abstract boolean isSelectorEmpty()
        Say if the list of IoSession polled by this IoProcessor is empty
        Returns:
        true if at least a session is managed by this IoProcessor

      • wakeup

        protected abstract void wakeup()
        Interrupt the select(long) call.

      • allSessions

        protected abstract java.util.Iterator<S> allSessions()
        Get an Iterator for the list of IoSession polled by this IoProcessor
        Returns:
        Iterator of IoSession

      • allSessionsCount

        protected abstract int allSessionsCount()
        Get the number of IoSession polled by this IoProcessor
        Returns:
        the number of sessions attached to this IoProcessor

      • selectedSessions

        protected abstract java.util.Iterator<S> selectedSessions()
        Get an Iterator for the list of IoSession found selected by the last call of select(long)
        Returns:
        Iterator of IoSession read for I/Os operation

      • getState

        protected abstract SessionState getState​(S session)
        Get the state of a session (One of OPENING, OPEN, CLOSING)
        Parameters:
        session - the IoSession to inspect
        Returns:
        the state of the session

      • isWritable

        protected abstract boolean isWritable​(S session)
        Tells if the session ready for writing
        Parameters:
        session - the queried session
        Returns:
        true is ready, false if not ready

      • isReadable

        protected abstract boolean isReadable​(S session)
        Tells if the session ready for reading
        Parameters:
        session - the queried session
        Returns:
        true is ready, false if not ready

      • setInterestedInWrite

        protected abstract void setInterestedInWrite​(S session,
                                             boolean isInterested)
                                      throws java.lang.Exception
        Set the session to be informed when a write event should be processed
        Parameters:
        session - the session for which we want to be interested in write events
        isInterested - true for registering, false for removing
        Throws:
        java.lang.Exception - If there was a problem while registering the session

      • setInterestedInRead

        protected abstract void setInterestedInRead​(S session,
                                            boolean isInterested)
                                     throws java.lang.Exception
        Set the session to be informed when a read event should be processed
        Parameters:
        session - the session for which we want to be interested in read events
        isInterested - true for registering, false for removing
        Throws:
        java.lang.Exception - If there was a problem while registering the session

      • isInterestedInRead

        protected abstract boolean isInterestedInRead​(S session)
        Tells if this session is registered for reading
        Parameters:
        session - the queried session
        Returns:
        true is registered for reading

      • isInterestedInWrite

        protected abstract boolean isInterestedInWrite​(S session)
        Tells if this session is registered for writing
        Parameters:
        session - the queried session
        Returns:
        true is registered for writing

      • init

        protected abstract void init​(S session)
                      throws java.lang.Exception
        Initialize the polling of a session. Add it to the polling process.
        Parameters:
        session - the IoSession to add to the polling
        Throws:
        java.lang.Exception - any exception thrown by the underlying system calls

      • destroy

        protected abstract void destroy​(S session)
                         throws java.lang.Exception
        Destroy the underlying client socket handle
        Parameters:
        session - the IoSession
        Throws:
        java.lang.Exception - any exception thrown by the underlying system calls

      • read

        protected abstract int read​(S session,
                            IoBuffer buf)
                     throws java.lang.Exception
        Reads a sequence of bytes from a IoSession into the given IoBuffer. Is called when the session was found ready for reading.
        Parameters:
        session - the session to read
        buf - the buffer to fill
        Returns:
        the number of bytes read
        Throws:
        java.lang.Exception - any exception thrown by the underlying system calls

      • write

        protected abstract int write​(S session,
                             IoBuffer buf,
                             int length)
                      throws java.io.IOException
        Write a sequence of bytes to a IoSession, means to be called when a session was found ready for writing.
        Parameters:
        session - the session to write
        buf - the buffer to write
        length - the number of bytes to write can be superior to the number of bytes remaining in the buffer
        Returns:
        the number of byte written
        Throws:
        java.io.IOException - any exception thrown by the underlying system calls

      • transferFile

        protected abstract int transferFile​(S session,
                                    FileRegion region,
                                    int length)
                             throws java.lang.Exception
        Write a part of a file to a IoSession, if the underlying API isn't supporting system calls like sendfile(), you can throw a UnsupportedOperationException so the file will be send using usual write(AbstractIoSession, IoBuffer, int) call.
        Parameters:
        session - the session to write
        region - the file region to write
        length - the length of the portion to send
        Returns:
        the number of written bytes
        Throws:
        java.lang.Exception - any exception thrown by the underlying system calls

      • add

        public final void add​(S session)
        Adds the specified session to the I/O processor so that the I/O processor starts to perform any I/O operations related with the session.
        Specified by:
        add in interface IoProcessor<S extends AbstractIoSession>
        Parameters:
        session - The added session

      • remove

        public final void remove​(S session)
        Removes and closes the specified session from the I/O processor so that the I/O processor closes the connection associated with the session and releases any other related resources.
        Specified by:
        remove in interface IoProcessor<S extends AbstractIoSession>
        Parameters:
        session - The session to be removed

      • scheduleRemove

        private void scheduleRemove​(S session)

      • write

        public void write​(S session,
                  WriteRequest writeRequest)
        Writes the WriteRequest for the specified session.
        Specified by:
        write in interface IoProcessor<S extends AbstractIoSession>
        Parameters:
        session - The session we want the message to be written
        writeRequest - the WriteRequest to write

      • flush

        public final void flush​(S session)
        Flushes the internal write request queue of the specified session.
        Specified by:
        flush in interface IoProcessor<S extends AbstractIoSession>
        Parameters:
        session - The session we want the message to be written

      • updateTrafficMask

        public final void updateTrafficMask​(S session)
        Updates the traffic mask for a given session
        Parameters:
        session - the session to update

      • startupProcessor

        private void startupProcessor()
        Starts the inner Processor, asking the executor to pick a thread in its pool. The Runnable will be renamed

      • registerNewSelector

        protected abstract void registerNewSelector()
                                     throws java.io.IOException
        In the case we are using the java select() method, this method is used to trash the buggy selector and create a new one, registring all the sockets on it.
        Throws:
        java.io.IOException - If we got an exception

      • isBrokenConnection

        protected abstract boolean isBrokenConnection()
                                       throws java.io.IOException
        Check that the select() has not exited immediately just because of a broken connection. In this case, this is a standard case, and we just have to loop.
        Returns:
        true if a connection has been brutally closed.
        Throws:
        java.io.IOException - If we got an exception

      • read

        private void read​(S session)