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                                 for (String data = rec(); data != null; data = rec()) {
  73                                         String rep = null;
  74                                         try {
  75                                                 rep = onRequest(this, clientVersion, data);
  76                                                 if (isClosing()) {
  77                                                         return;
  78                                                 }
  79                                         } catch (Exception e) {
  80                                                 onError(e);
  81                                         }
  82
  83                                         if (rep == null) {
  84                                                 rep = "";
  85                                         }
  86
  87                                         send(rep);
  88                                 }
  89                         }
  90
  91                         @Override
  92                         protected void onError(Exception e) {
  93                                 ServerString.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 (NULL will be
 102          * converted to an empty {@link String}).
 103          *
 104          * @param action
 105          *            the client action
 106          * @param clientVersion
 107          *            the client version
 108          * @param data
 109          *            the data sent by the client
 110          *
 111          * @return the answer to return to the client
 112          *
 113          * @throws Exception
 114          *             in case of an exception, the error will only be logged
 115          */
 116         abstract protected String onRequest(ConnectActionServerString action,
 117                         Version clientVersion, String data) throws Exception;
 118 }