src/be/nikiroo/utils/serial/server/ServerObject.java

   1 package be.nikiroo.utils.serial.server;
   2
   3 import java.io.IOException;
   4 import java.net.Socket;
   5 import java.net.UnknownHostException;
   6
   7 /**
   8  * This class implements a simple server that can listen for connections and
   9  * send/receive objects.
  10  * <p>
  11  * Note: this {@link ServerObject} has to be discarded after use (cannot be
  12  * started twice).
  13  *
  14  * @author niki
  15  */
  16 abstract public class ServerObject extends Server {
  17         /**
  18          * Create a new server that will start listening on the network when
  19          * {@link ServerObject#start()} is called.
  20          *
  21          * @param port
  22          *            the port to listen on, or 0 to assign any unallocated port
  23          *            found (which can later on be queried via
  24          *            {@link ServerObject#getPort()}
  25          * @param key
  26          *            an optional key to encrypt all the communications (if NULL,
  27          *            everything will be sent in clear text)
  28          *
  29          * @throws IOException
  30          *             in case of I/O error
  31          * @throws UnknownHostException
  32          *             if the IP address of the host could not be determined
  33          * @throws IllegalArgumentException
  34          *             if the port parameter is outside the specified range of valid
  35          *             port values, which is between 0 and 65535, inclusive
  36          */
  37         public ServerObject(int port, String key) throws IOException {
  38                 super(port, key);
  39         }
  40
  41         /**
  42          * Create a new server that will start listening on the network when
  43          * {@link ServerObject#start()} is called.
  44          *
  45          * @param name
  46          *            the server name (only used for debug info and traces)
  47          * @param port
  48          *            the port to listen on
  49          * @param key
  50          *            an optional key to encrypt all the communications (if NULL,
  51          *            everything will be sent in clear text)
  52          *
  53          * @throws IOException
  54          *             in case of I/O error
  55          * @throws UnknownHostException
  56          *             if the IP address of the host could not be determined
  57          * @throws IllegalArgumentException
  58          *             if the port parameter is outside the specified range of valid
  59          *             port values, which is between 0 and 65535, inclusive
  60          */
  61         public ServerObject(String name, int port, String key) throws IOException {
  62                 super(name, port, key);
  63         }
  64
  65         @Override
  66         protected ConnectActionServer createConnectActionServer(Socket s) {
  67                 return new ConnectActionServerObject(s, key) {
  68                         @Override
  69                         public void action() throws Exception {
  70                                 try {
  71                                         for (Object data = rec(); true; data = rec()) {
  72                                                 Object rep = null;
  73                                                 try {
  74                                                         rep = onRequest(this, data);
  75                                                         if (isClosing()) {
  76                                                                 return;
  77                                                         }
  78                                                 } catch (Exception e) {
  79                                                         onError(e);
  80                                                 }
  81                                                 send(rep);
  82                                         }
  83                                 } catch (NullPointerException e) {
  84                                         // Client has no data any more, we quit
  85                                 }
  86                         }
  87
  88                         @Override
  89                         protected void onError(Exception e) {
  90                                 ServerObject.this.onError(e);
  91                         }
  92                 };
  93         }
  94
  95         /**
  96          * This is the method that is called on each client request.
  97          * <p>
  98          * You are expected to react to it and return an answer (which can be NULL).
  99          *
 100          * @param action
 101          *            the client action
 102          * @param data
 103          *            the data sent by the client (which can be NULL)
 104          *
 105          * @return the answer to return to the client (which can be NULL)
 106          *
 107          * @throws Exception
 108          *             in case of an exception, the error will only be logged
 109          */
 110         abstract protected Object onRequest(ConnectActionServerObject action,
 111                         Object data) throws Exception;
 112 }