/*

  *   SONEWS News Server

  *   see AUTHORS for the list of contributors

  *

  *   This program is free software: you can redistribute it and/or modify

  *   it under the terms of the GNU General Public License as published by

  *   the Free Software Foundation, either version 3 of the License, or

  *   (at your option) any later version.

  *

  *   This program is distributed in the hope that it will be useful,

  *   but WITHOUT ANY WARRANTY; without even the implied warranty of

  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  *   GNU General Public License for more details.

  *

  *   You should have received a copy of the GNU General Public License

  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.

  */

 package org.sonews.daemon;

 import java.io.IOException;

 import java.nio.ByteBuffer;

 import java.nio.channels.CancelledKeyException;

 import java.nio.channels.SelectionKey;

 import java.nio.channels.Selector;

 import java.nio.channels.SocketChannel;

 import java.util.Iterator;

 import java.util.Set;

 import org.sonews.util.Log;

 /**

  * A Thread task listening for OP_READ events from SocketChannels.

  * @author Christian Lins

  * @since sonews/0.5.0

  */

 class ChannelReader extends AbstractDaemon

 {

   private static ChannelReader instance = new ChannelReader();

   /**

    * @return Active ChannelReader instance.

    */

   public static ChannelReader getInstance()

   {

     return instance;

   }

   private Selector selector = null;

   protected ChannelReader()

   {

   }

   /**

    * Sets the selector which is used by this reader to determine the channel

    * to read from.

    * @param selector

    */

   public void setSelector(final Selector selector)

   {

     this.selector = selector;

   }

   /**

    * Run loop. Blocks until some data is available in a channel.

    */

   @Override

   public void run()

   {

     assert selector != null;

     while(isRunning())

     {

       try

       {

         // select() blocks until some SelectableChannels are ready for

         // processing. There is no need to lock the selector as we have only

         // one thread per selector.

         selector.select();

         // Get list of selection keys with pending events.

         // Note: the selected key set is not thread-safe

         SocketChannel channel = null;

         NNTPConnection conn = null;

         final Set<SelectionKey> selKeys = selector.selectedKeys();

         SelectionKey selKey = null;

         synchronized (selKeys)

         {

           Iterator it = selKeys.iterator();

           // Process the first pending event

           while (it.hasNext())

           {

             selKey = (SelectionKey) it.next();

             channel = (SocketChannel) selKey.channel();

             conn = Connections.getInstance().get(channel);

             // Because we cannot lock the selKey as that would cause a deadlock

             // we lock the connection. To preserve the order of the received

             // byte blocks a selection key for a connection that has pending

             // read events is skipped.

             if (conn == null || conn.tryReadLock())

             {

               // Remove from set to indicate that it's being processed

               it.remove();

               if (conn != null)

               {

                 break; // End while loop

               }

             }

             else

             {

               selKey = null;

               channel = null;

               conn = null;

             }

           }

         }

         // Do not lock the selKeys while processing because this causes

         // a deadlock in sun.nio.ch.SelectorImpl.lockAndDoSelect()

         if (selKey != null && channel != null && conn != null)

         {

           processSelectionKey(conn, channel, selKey);

           conn.unlockReadLock();

         }

       }

       catch(CancelledKeyException ex)

       {

         Log.msg("ChannelReader.run(): " + ex, false);

         if(Log.isDebug())

         {

           ex.printStackTrace();

         }

       }

       catch(Exception ex)

       {

         ex.printStackTrace();

       }

       // Eventually wait for a register operation

       synchronized (NNTPDaemon.RegisterGate)

       {

       // Do nothing; FindBugs may warn about an empty synchronized 

       // statement, but we cannot use a wait()/notify() mechanism here.

       // If we used something like RegisterGate.wait() we block here

       // until the NNTPDaemon calls notify(). But the daemon only

       // calls notify() if itself is NOT blocked in the listening socket.

       }

     } // while(isRunning())

   }

   private void processSelectionKey(final NNTPConnection connection,

     final SocketChannel socketChannel, final SelectionKey selKey)

     throws InterruptedException, IOException

   {

     assert selKey != null;

     assert selKey.isReadable();

     // Some bytes are available for reading

     if(selKey.isValid())

     {   

       // Lock the channel

       //synchronized(socketChannel)

       {

         // Read the data into the appropriate buffer

         ByteBuffer buf = connection.getInputBuffer();

         int read = -1;

         try 

         {

           read = socketChannel.read(buf);

         }

         catch(IOException ex)

         {

           // The connection was probably closed by the remote host

           // in a non-clean fashion

           Log.msg("ChannelReader.processSelectionKey(): " + ex, true);

         }

         catch(Exception ex) 

         {

           Log.msg("ChannelReader.processSelectionKey(): " + ex, false);

           if(Log.isDebug())

           {

             ex.printStackTrace();

           }

         }

         if(read == -1) // End of stream

         {

           selKey.cancel();

         }

         else if(read > 0) // If some data was read

         {

           ConnectionWorker.addChannel(socketChannel);

         }

       }

     }

     else

     {

       // Should not happen

       Log.msg(selKey, false);

     }

   }

 }