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

   1 package be.nikiroo.utils.serial.server;
   2
   3 import java.io.BufferedReader;
   4 import java.io.IOException;
   5 import java.io.InputStreamReader;
   6 import java.io.OutputStreamWriter;
   7 import java.net.Socket;
   8
   9 import be.nikiroo.utils.Version;
  10 import be.nikiroo.utils.serial.Exporter;
  11 import be.nikiroo.utils.serial.Importer;
  12
  13 /**
  14  * Base class used for the client/server basic handling.
  15  * <p>
  16  * It represents a single action: a client is expected to only execute one
  17  * action, while a server is expected to execute one action for each client
  18  * action.
  19  *
  20  * @author niki
  21  */
  22 abstract class ConnectAction {
  23         private Socket s;
  24         private boolean server;
  25         private Version version;
  26         private Version clientVersion;
  27
  28         private Object lock = new Object();
  29         private BufferedReader in;
  30         private OutputStreamWriter out;
  31         private boolean contentToSend;
  32
  33         /**
  34          * Method that will be called when an action is performed on either the
  35          * client or server this {@link ConnectAction} represent.
  36          *
  37          * @param version
  38          *            the counter part version
  39          *
  40          * @throws Exception
  41          *             in case of I/O error
  42          */
  43         abstract protected void action(Version version) throws Exception;
  44
  45         /**
  46          * Method called when we negotiate the version with the client.
  47          * <p>
  48          * Thus, it is only called on the server.
  49          * <p>
  50          * Will return the actual server version by default.
  51          *
  52          * @param clientVersion
  53          *            the client version
  54          *
  55          * @return the version to send to the client
  56          */
  57         abstract protected Version negotiateVersion(Version clientVersion);
  58
  59         /**
  60          * Handler called when an unexpected error occurs in the code.
  61          *
  62          * @param e
  63          *            the exception that occurred
  64          */
  65         abstract protected void onError(Exception e);
  66
  67         /**
  68          * Create a new {@link ConnectAction}.
  69          *
  70          * @param s
  71          *            the socket to bind to
  72          * @param server
  73          *            TRUE for a server action, FALSE for a client action (will
  74          *            impact the process)
  75          * @param version
  76          *            the version of this client-or-server
  77          */
  78         protected ConnectAction(Socket s, boolean server, Version version) {
  79                 this.s = s;
  80                 this.server = server;
  81
  82                 if (version == null) {
  83                         this.version = new Version();
  84                 } else {
  85                         this.version = version;
  86                 }
  87
  88                 clientVersion = new Version();
  89         }
  90
  91         /**
  92          * The version of this client-or-server.
  93          *
  94          * @return the version
  95          */
  96         public Version getVersion() {
  97                 return version;
  98         }
  99
 100         /**
 101          * Actually start the process (this is synchronous).
 102          */
 103         public void connect() {
 104                 try {
 105                         in = new BufferedReader(new InputStreamReader(s.getInputStream(),
 106                                         "UTF-8"));
 107                         try {
 108                                 out = new OutputStreamWriter(s.getOutputStream(), "UTF-8");
 109                                 try {
 110                                         if (server) {
 111                                                 String line = in.readLine();
 112                                                 if (line != null && line.startsWith("VERSION ")) {
 113                                                         // "VERSION client-version" (VERSION 1.0.0)
 114                                                         Version clientVersion = new Version(
 115                                                                         line.substring("VERSION ".length()));
 116                                                         this.clientVersion = clientVersion;
 117                                                         Version v = negotiateVersion(clientVersion);
 118                                                         if (v == null) {
 119                                                                 v = new Version();
 120                                                         }
 121
 122                                                         sendString("VERSION " + v.toString());
 123                                                 }
 124
 125                                                 action(clientVersion);
 126                                         } else {
 127                                                 String v = sendString("VERSION " + version.toString());
 128                                                 if (v != null && v.startsWith("VERSION ")) {
 129                                                         v = v.substring("VERSION ".length());
 130                                                 }
 131
 132                                                 action(new Version(v));
 133                                         }
 134                                 } finally {
 135                                         out.close();
 136                                         out = null;
 137                                 }
 138                         } finally {
 139                                 in.close();
 140                                 in = null;
 141                         }
 142                 } catch (Exception e) {
 143                         onError(e);
 144                 } finally {
 145                         try {
 146                                 s.close();
 147                         } catch (Exception e) {
 148                                 onError(e);
 149                         }
 150                 }
 151         }
 152
 153         /**
 154          * Serialise and send the given object to the counter part (and, only for
 155          * client, return the deserialised answer -- the server will always receive
 156          * NULL).
 157          *
 158          * @param data
 159          *            the data to send
 160          *
 161          * @return the answer (which can be NULL) if this action is a client, always
 162          *         NULL if it is a server
 163          *
 164          * @throws IOException
 165          *             in case of I/O error
 166          * @throws NoSuchFieldException
 167          *             if the serialised data contains information about a field
 168          *             which does actually not exist in the class we know of
 169          * @throws NoSuchMethodException
 170          *             if a class described in the serialised data cannot be created
 171          *             because it is not compatible with this code
 172          * @throws ClassNotFoundException
 173          *             if a class described in the serialised data cannot be found
 174          */
 175         protected Object sendObject(Object data) throws IOException,
 176                         NoSuchFieldException, NoSuchMethodException, ClassNotFoundException {
 177                 synchronized (lock) {
 178                         String rep = sendString(new Exporter().append(data).toString(true));
 179                         if (rep != null) {
 180                                 return new Importer().read(rep).getValue();
 181                         }
 182
 183                         return null;
 184                 }
 185         }
 186
 187         /**
 188          * Reserved for the server: flush the data to the client and retrieve its
 189          * answer.
 190          * <p>
 191          * Also used internally for the client (only do something if there is
 192          * contentToSend).
 193          * <p>
 194          * Will only flush the data if there is contentToSend.
 195          *
 196          * @return the deserialised answer (which can actually be NULL)
 197          *
 198          * @throws IOException
 199          *             in case of I/O error
 200          * @throws NoSuchFieldException
 201          *             if the serialised data contains information about a field
 202          *             which does actually not exist in the class we know of
 203          * @throws NoSuchMethodException
 204          *             if a class described in the serialised data cannot be created
 205          *             because it is not compatible with this code
 206          * @throws ClassNotFoundException
 207          *             if a class described in the serialised data cannot be found
 208          * @throws java.lang.NullPointerException
 209          *             if the counter part has no data to send
 210          */
 211         protected Object recObject() throws IOException, NoSuchFieldException,
 212                         NoSuchMethodException, ClassNotFoundException,
 213                         java.lang.NullPointerException {
 214                 String str = recString();
 215                 if (str == null) {
 216                         throw new NullPointerException("No more data available");
 217                 }
 218
 219                 return new Importer().read(str).getValue();
 220         }
 221
 222         /**
 223          * Send the given string to the counter part (and, only for client, return
 224          * the answer -- the server will always receive NULL).
 225          *
 226          * @param line
 227          *            the data to send (we will add a line feed)
 228          *
 229          * @return the answer if this action is a client (without the added line
 230          *         feed), NULL if it is a server
 231          *
 232          * @throws IOException
 233          *             in case of I/O error
 234          */
 235         protected String sendString(String line) throws IOException {
 236                 synchronized (lock) {
 237                         out.write(line);
 238                         out.write("\n");
 239
 240                         if (server) {
 241                                 out.flush();
 242                                 return null;
 243                         }
 244
 245                         contentToSend = true;
 246                         return recString();
 247                 }
 248         }
 249
 250         /**
 251          * Reserved for the server (externally): flush the data to the client and
 252          * retrieve its answer.
 253          * <p>
 254          * Also used internally for the client (only do something if there is
 255          * contentToSend).
 256          * <p>
 257          * Will only flush the data if there is contentToSend.
 258          *
 259          * @return the answer (which can be NULL)
 260          *
 261          * @throws IOException
 262          *             in case of I/O error
 263          */
 264         protected String recString() throws IOException {
 265                 synchronized (lock) {
 266                         if (server || contentToSend) {
 267                                 if (contentToSend) {
 268                                         out.flush();
 269                                         contentToSend = false;
 270                                 }
 271
 272                                 return in.readLine();
 273                         }
 274
 275                         return null;
 276                 }
 277         }
 278 }