/*

  *   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 org.sonews.config.Config;

 import org.sonews.Main;

 import org.sonews.util.Log;

 import java.io.IOException;

 import java.net.BindException;

 import java.net.InetSocketAddress;

 import java.net.ServerSocket;

 import java.nio.channels.CancelledKeyException;

 import java.nio.channels.ClosedChannelException;

 import java.nio.channels.SelectionKey;

 import java.nio.channels.Selector;

 import java.nio.channels.ServerSocketChannel;

 import java.nio.channels.SocketChannel;

 /**

  * NNTP daemon using SelectableChannels.

  * @author Christian Lins

  * @since sonews/0.5.0

  */

 public final class NNTPDaemon extends AbstractDaemon

 {

   public static final Object RegisterGate = new Object();

   private static NNTPDaemon instance = null;

   public static synchronized NNTPDaemon createInstance(int port)

   {

     if(instance == null)

     {

       instance = new NNTPDaemon(port);

       return instance;

     }

     else

     {

       throw new RuntimeException("NNTPDaemon.createInstance() called twice");

     }

   }

   private int port;

   private NNTPDaemon(final int port)

   {

     Log.get().info("Server listening on port " + port);

     this.port = port;

   }

   @Override

   public void run()

   {

     try

     {

       // Create a Selector that handles the SocketChannel multiplexing

       final Selector readSelector  = Selector.open();

       final Selector writeSelector = Selector.open();

       // Start working threads

       final int workerThreads = Runtime.getRuntime().availableProcessors() * 4;

       ConnectionWorker[] cworkers = new ConnectionWorker[workerThreads];

       for(int n = 0; n < workerThreads; n++)

       {

         cworkers[n] = new ConnectionWorker();

         cworkers[n].start();

       }

       ChannelWriter.getInstance().setSelector(writeSelector);

       ChannelReader.getInstance().setSelector(readSelector);

       ChannelWriter.getInstance().start();

       ChannelReader.getInstance().start();

       final ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

       serverSocketChannel.configureBlocking(true);  // Set to blocking mode

       // Configure ServerSocket; bind to socket...

       final ServerSocket serverSocket = serverSocketChannel.socket();

       serverSocket.bind(new InetSocketAddress(this.port));

       while(isRunning())

       {

         SocketChannel socketChannel;

         try

         {

           // As we set the server socket channel to blocking mode the accept()

           // method will block.

           socketChannel = serverSocketChannel.accept();

           socketChannel.configureBlocking(false);

           assert socketChannel.isConnected();

           assert socketChannel.finishConnect();

         }

         catch(IOException ex)

         {

           // Under heavy load an IOException "Too many open files may

           // be thrown. It most cases we should slow down the connection

           // accepting, to give the worker threads some time to process work.

           Log.get().severe("IOException while accepting connection: " + ex.getMessage());

           Log.get().info("Connection accepting sleeping for seconds...");

           Thread.sleep(5000); // 5 seconds

           continue;

         }

         final NNTPConnection conn;

         try

         {

           conn = new NNTPConnection(socketChannel);

           Connections.getInstance().add(conn);

         }

         catch(IOException ex)

         {

           Log.get().warning(ex.toString());

           socketChannel.close();

           continue;

         }

         try

         {

           SelectionKey selKeyWrite =

             registerSelector(writeSelector, socketChannel, SelectionKey.OP_WRITE);

           registerSelector(readSelector, socketChannel, SelectionKey.OP_READ);

           Log.get().info("Connected: " + socketChannel.socket().getRemoteSocketAddress());

           // Set write selection key and send hello to client

           conn.setWriteSelectionKey(selKeyWrite);

           conn.println("200 " + Config.inst().get(Config.HOSTNAME, "localhost")

               + " " + Main.VERSION + " news server ready - (posting ok).");

         }

         catch(CancelledKeyException cke)

         {

           Log.get().warning("CancelledKeyException " + cke.getMessage() + " was thrown: "

             + socketChannel.socket());

         }

         catch(ClosedChannelException cce)

         {

           Log.get().warning("ClosedChannelException " + cce.getMessage() + " was thrown: "

             + socketChannel.socket());

         }

       }

     }

     catch(BindException ex)

     {

       // Could not bind to socket; this is a fatal problem; so perform shutdown

       ex.printStackTrace();

       System.exit(1);

     }

     catch(IOException ex)

     {

       ex.printStackTrace();

     }

     catch(Exception ex)

     {

       ex.printStackTrace();

     }

   }

   public static SelectionKey registerSelector(final Selector selector,

     final SocketChannel channel, final int op)

     throws CancelledKeyException, ClosedChannelException

   {

     // Register the selector at the channel, so that it will be notified

     // on the socket's events

     synchronized(RegisterGate)

     {

       // Wakeup the currently blocking reader/writer thread; we have locked

       // the RegisterGate to prevent the awakened thread to block again

       selector.wakeup();

       // Lock the selector to prevent the waiting worker threads going into

       // selector.select() which would block the selector.

       synchronized (selector)

       {

         return channel.register(selector, op, null);

       }

     }

   }

 }