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 import be.nikiroo.utils.Version;
   8
   9 /**
  10  * This class implements a simple server that can listen for connections and
  11  * send/receive objects.
  12  * <p>
  13  * Note: this {@link ServerObject} has to be discarded after use (cannot be
  14  * started twice).
  15  *
  16  * @author niki
  17  */
  18 abstract public class ServerObject extends Server {
  19         /**
  20          * Create a new server that will start listening on the network when
  21          * {@link ServerObject#start()} is called.
  22          *
  23          * @param port
  24          *            the port to listen on, or 0 to assign any unallocated port
  25          *            found (which can later on be queried via
  26          *            {@link ServerObject#getPort()}
  27          * @param key
  28          *            an optional key to encrypt all the communications (if NULL,
  29          *            everything will be sent in clear text)
  30          *
  31          * @throws IOException
  32          *             in case of I/O error
  33          * @throws UnknownHostException
  34          *             if the IP address of the host could not be determined
  35          * @throws IllegalArgumentException
  36          *             if the port parameter is outside the specified range of valid
  37          *             port values, which is between 0 and 65535, inclusive
  38          */
  39         public ServerObject(int port, String key) throws IOException {
  40                 super(port, key);
  41         }
  42
  43         /**
  44          * Create a new server that will start listening on the network when
  45          * {@link ServerObject#start()} is called.
  46          *
  47          * @param name
  48          *            the server name (only used for debug info and traces)
  49          * @param port
  50          *            the port to listen on
  51          * @param key
  52          *            an optional key to encrypt all the communications (if NULL,
  53          *            everything will be sent in clear text)
  54          *
  55          * @throws IOException
  56          *             in case of I/O error
  57          * @throws UnknownHostException
  58          *             if the IP address of the host could not be determined
  59          * @throws IllegalArgumentException
  60          *             if the port parameter is outside the specified range of valid
  61          *             port values, which is between 0 and 65535, inclusive
  62          */
  63         public ServerObject(String name, int port, String key) throws IOException {
  64                 super(name, port, key);
  65         }
  66
  67         @Override
  68         protected ConnectActionServer createConnectActionServer(Socket s) {
  69                 return new ConnectActionServerObject(s, key) {
  70                         @Override
  71                         public void action(Version clientVersion) throws Exception {
  72                                 long id = getNextId();
  73                                 try {
  74                                         for (Object data = rec(); true; data = rec()) {
  75                                                 Object rep = null;
  76                                                 try {
  77                                                         rep = onRequest(this, clientVersion, data, id);
  78                                                         if (isClosing()) {
  79                                                                 return;
  80                                                         }
  81                                                 } catch (Exception e) {
  82                                                         onError(e);
  83                                                 }
  84
  85                                                 send(rep);
  86                                         }
  87                                 } catch (NullPointerException e) {
  88                                         // Client has no data any more, we quit
  89                                         onRequestDone(id, getBytesReceived(), getBytesSent());
  90                                 }
  91                         }
  92
  93                         @Override
  94                         protected void onError(Exception e) {
  95                                 ServerObject.this.onError(e);
  96                         }
  97                 };
  98         }
  99
 100         @Override
 101         protected ConnectActionClient getConnectionToMe()
 102                         throws UnknownHostException, IOException {
 103                 return new ConnectActionClientObject(new Socket((String) null,
 104                                 getPort()), key);
 105         }
 106
 107         /**
 108          * This is the method that is called on each client request.
 109          * <p>
 110          * You are expected to react to it and return an answer (which can be NULL).
 111          *
 112          * @param action
 113          *            the client action
 114          * @param data
 115          *            the data sent by the client (which can be NULL)
 116          * @param id
 117          *            an ID to identify this request (will also be re-used for
 118          *            {@link ServerObject#onRequestDone(long, long, long)}.
 119          *
 120          * @return the answer to return to the client (which can be NULL)
 121          *
 122          * @throws Exception
 123          *             in case of an exception, the error will only be logged
 124          */
 125         protected Object onRequest(ConnectActionServerObject action,
 126                         Version clientVersion, Object data,
 127                         @SuppressWarnings("unused") long id) throws Exception {
 128                 // TODO: change to abstract when deprecated method is removed
 129                 // Default implementation for compat
 130                 return onRequest(action, clientVersion, data);
 131         }
 132
 133         // Deprecated //
 134
 135         /**
 136          * @deprecated SSL support has been replaced by key-based encryption.
 137          *             <p>
 138          *             Please use the version with key encryption (this deprecated
 139          *             version uses an empty key when <tt>ssl</tt> is TRUE and no
 140          *             key (NULL) when <tt>ssl</tt> is FALSE).
 141          */
 142         @Deprecated
 143         public ServerObject(int port, boolean ssl) throws IOException {
 144                 this(port, ssl ? "" : null);
 145         }
 146
 147         /**
 148          * @deprecated SSL support has been replaced by key-based encryption.
 149          *             <p>
 150          *             Please use the version with key encryption (this deprecated
 151          *             version uses an empty key when <tt>ssl</tt> is TRUE and no
 152          *             key (NULL) when <tt>ssl</tt> is FALSE).
 153          */
 154         @Deprecated
 155         public ServerObject(String name, int port, boolean ssl) throws IOException {
 156                 this(name, port, ssl ? "" : null);
 157         }
 158
 159         /**
 160          * Will be called if the correct version is not overrided.
 161          *
 162          * @deprecated use the version with the id.
 163          *
 164          * @param action
 165          *            the client action
 166          * @param data
 167          *            the data sent by the client
 168          *
 169          * @return the answer to return to the client
 170          *
 171          * @throws Exception
 172          *             in case of an exception, the error will only be logged
 173          */
 174         @Deprecated
 175         @SuppressWarnings("unused")
 176         protected Object onRequest(ConnectActionServerObject action,
 177                         Version version, Object data) throws Exception {
 178                 return null;
 179         }
 180 }