Class AbstractPollingIoProcessor<S extends AbstractIoSession>

    • Method Detail

      • 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.
      • allSessionsCount

        protected abstract int allSessionsCount()
        Get the number of IoSession polled by this IoProcessor
        Returns:
        the number of sessions attached to this IoProcessor
      • 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
      • 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
      • 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