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                                 long id = getNextId();
  71                                 try {
  72                                         for (Object data = rec(); true; data = rec()) {
  73                                                 Object rep = null;
  74                                                 try {
  75                                                         rep = onRequest(this, data, id);
  76                                                         if (isClosing()) {
  77                                                                 return;
  78                                                         }
  79                                                 } catch (Exception e) {
  80                                                         onError(e);
  81                                                 }
  82
  83                                                 send(rep);
  84                                         }
  85                                 } catch (NullPointerException e) {
  86                                         // Client has no data any more, we quit
  87                                         onRequestDone(id, getBytesReceived(), getBytesSent());
  88                                 }
  89                         }
  90
  91                         @Override
  92                         protected void onError(Exception e) {
  93                                 ServerObject.this.onError(e);
  94                         }
  95                 };
  96         }
  97
  98         /**
  99          * This is the method that is called on each client request.
 100          * <p>
 101          * You are expected to react to it and return an answer (which can be NULL).
 102          *
 103          * @param action
 104          *            the client action
 105          * @param data
 106          *            the data sent by the client (which can be NULL)
 107          * @param id
 108          *            an ID to identify this request (will also be re-used for
 109          *            {@link ServerObject#onRequestDone(long, long, long)}.
 110          *
 111          * @return the answer to return to the client (which can be NULL)
 112          *
 113          * @throws Exception
 114          *             in case of an exception, the error will only be logged
 115          */
 116         abstract protected Object onRequest(ConnectActionServerObject action,
 117                         Object data, long id) throws Exception;
 118 }