src/be/nikiroo/utils/serial/server/ServerString.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 Strings.
  12  * <p>
  13  * Note: this {@link ServerString} has to be discarded after use (cannot be
  14  * started twice).
  15  *
  16  * @author niki
  17  */
  18 abstract public class ServerString extends Server {
  19         /**
  20          * Create a new server that will start listening on the network when
  21          * {@link ServerString#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 ServerString#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 ServerString(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 ServerString#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 ServerString(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 ConnectActionServerString(s, key) {
  70                         @Override
  71                         public void action(Version clientVersion) throws Exception {
  72                                 long id = getNextId();
  73                                 for (String data = rec(); data != null; data = rec()) {
  74                                         String rep = null;
  75                                         try {
  76                                                 rep = onRequest(this, data, id);
  77                                                 if (isClosing()) {
  78                                                         return;
  79                                                 }
  80                                         } catch (Exception e) {
  81                                                 onError(e);
  82                                         }
  83
  84                                         if (rep == null) {
  85                                                 rep = "";
  86                                         }
  87                                         send(rep);
  88                                 }
  89
  90                                 onRequestDone(id, getBytesReceived(), getBytesSent());
  91                         }
  92
  93                         @Override
  94                         protected void onError(Exception e) {
  95                                 ServerString.this.onError(e);
  96                         }
  97                 };
  98         }
  99
 100         @Override
 101         protected ConnectActionClient getConnectionToMe()
 102                         throws UnknownHostException, IOException {
 103                 return new ConnectActionClientString(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 (NULL will be
 111          * converted to an empty {@link String}).
 112          *
 113          * @param action
 114          *            the client action
 115          * @param data
 116          *            the data sent by the client
 117          * @param id
 118          *            an ID to identify this request (will also be re-used for
 119          *            {@link ServerObject#onRequestDone(long, long, long)}.
 120          *
 121          * @return the answer to return to the client
 122          *
 123          * @throws Exception
 124          *             in case of an exception, the error will only be logged
 125          */
 126         abstract protected String onRequest(ConnectActionServerString action,
 127                         String data, long id) throws Exception;
 128 }