Class AbstractPollingIoProcessor<S extends AbstractIoSession>

java.lang.Object
org.apache.mina.core.polling.AbstractPollingIoProcessor<S>
Type Parameters:
S - the type of the IoSession this processor can handle
All Implemented Interfaces:
IoProcessor<S>
Direct Known Subclasses:
AprIoProcessor, NioProcessor
public abstract class AbstractPollingIoProcessor<S extends AbstractIoSession> extends Object implements IoProcessor<S>
An abstract implementation of IoProcessor which helps transport developers to write an IoProcessor easily. This class is in charge of active polling a set of IoSession and trigger events when some I/O operation is possible.

  • Field Details

    • 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:

    • threadIds

      private static final ConcurrentHashMap<Class<?>, AtomicInteger> threadIds
      A map containing the last Thread ID for each class

    • threadName

      private final String threadName
      This IoProcessor instance name

    • executor

      private final Executor executor
      The executor to use when we need to start the inner Processor

    • newSessions

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

    • removingSessions

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

    • flushingSessions

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

    • trafficControllingSessions

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

    • processorRef

      private final AtomicReference<AbstractPollingIoProcessor<S extends AbstractIoSession>.Processor> processorRef
      The processor thread : it handles the incoming messages

    • lastIdleCheckTime

      private long lastIdleCheckTime

    • disposalLock

      private final Object disposalLock

    • disposing

      private volatile boolean disposing

    • disposed

      private volatile boolean disposed

    • disposalFuture

      private final DefaultIoFuture disposalFuture

    • wakeupCalled

      protected AtomicBoolean wakeupCalled

  • Constructor Details

  • Method Details

    • nextThreadName

      private 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.

    • isDisposing

      public final boolean isDisposing()
      Specified by:
      isDisposing in interface IoProcessor<S extends AbstractIoSession>
      Returns:
      true if and if only IoProcessor.dispose() method has been called. Please note that this method will return true even after all the related resources are released.

    • 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 Exception
      Dispose the resources used by this IoProcessor for polling the client connections. The implementing class doDispose method will be called.
      Throws:
      Exception - if some low level IO error occurs

    • select

      protected abstract int select(long timeout) throws 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:
      Exception - if some low level IO error occurs

    • select

      protected abstract int select() throws Exception
      poll those sessions forever
      Returns:
      The number of session ready for read or for write
      Throws:
      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 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 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 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:
      Exception - If there was a problem while registering the session

    • setInterestedInRead

      protected abstract void setInterestedInRead(S session, boolean isInterested) throws 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:
      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 Exception
      Initialize the polling of a session. Add it to the polling process.
      Parameters:
      session - the IoSession to add to the polling
      Throws:
      Exception - any exception thrown by the underlying system calls

    • destroy

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

    • read

      protected abstract int read(S session, IoBuffer buf) throws 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:
      Exception - any exception thrown by the underlying system calls

    • write

      protected abstract int write(S session, IoBuffer buf, int length) throws 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:
      IOException - any exception thrown by the underlying system calls

    • transferFile

      protected abstract int transferFile(S session, FileRegion region, int length) throws 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:
      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 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:
      IOException - If we got an exception

    • isBrokenConnection

      protected abstract boolean isBrokenConnection() throws 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:
      IOException - If we got an exception

    • read

      private void read(S session)

    • updateTrafficControl

      public void updateTrafficControl(S session)
      Controls the traffic of the specified session depending of the IoSession.isReadSuspended() and IoSession.isWriteSuspended() flags
      Specified by:
      updateTrafficControl in interface IoProcessor<S extends AbstractIoSession>
      Parameters:
      session - The session to be updated