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

   1 package be.nikiroo.utils.serial.server;
   2
   3 import java.io.IOException;
   4 import java.lang.reflect.Array;
   5 import java.net.Socket;
   6
   7 import be.nikiroo.utils.StringUtils;
   8 import be.nikiroo.utils.TraceHandler;
   9 import be.nikiroo.utils.Version;
  10 import be.nikiroo.utils.serial.Importer;
  11
  12 /**
  13  * This class implements a simple server that can bridge two other
  14  * {@link Server}s.
  15  * <p>
  16  * It can, of course, inspect the data that goes through it (by default, it
  17  * prints traces of the data).
  18  * <p>
  19  * Note: this {@link ServerBridge} has to be discarded after use (cannot be
  20  * started twice).
  21  *
  22  * @author niki
  23  */
  24 public class ServerBridge extends Server {
  25         private final String forwardToHost;
  26         private final int forwardToPort;
  27         private final boolean forwardToSsl;
  28
  29         /**
  30          * Create a new server that will start listening on the network when
  31          * {@link ServerBridge#start()} is called.
  32          *
  33          * @param port
  34          *            the port to listen on, or 0 to assign any unallocated port
  35          *            found (which can later on be queried via
  36          *            {@link ServerBridge#getPort()}
  37          * @param ssl
  38          *            use an SSL connection (or not)
  39          * @param forwardToHost
  40          *            the host server to forward the calls to
  41          * @param forwardToPort
  42          *            the host port to forward the calls to
  43          * @param forwardToSsl
  44          *            use an SSL connection for the forward server or not
  45          *
  46          * @throws IOException
  47          *             in case of I/O error
  48          */
  49         public ServerBridge(int port, boolean ssl, String forwardToHost,
  50                         int forwardToPort, boolean forwardToSsl) throws IOException {
  51                 super(port, ssl);
  52                 this.forwardToHost = forwardToHost;
  53                 this.forwardToPort = forwardToPort;
  54                 this.forwardToSsl = forwardToSsl;
  55         }
  56
  57         /**
  58          * Create a new server that will start listening on the network when
  59          * {@link ServerBridge#start()} is called.
  60          *
  61          * @param name
  62          *            the server name (only used for debug info and traces)
  63          * @param port
  64          *            the port to listen on
  65          * @param ssl
  66          *            use an SSL connection (or not)
  67          * @param forwardToHost
  68          *            the host server to forward the calls to
  69          * @param forwardToPort
  70          *            the host port to forward the calls to
  71          * @param forwardToSsl
  72          *            use an SSL connection for the forward server or not
  73          *
  74          * @throws IOException
  75          *             in case of I/O error
  76          */
  77         public ServerBridge(String name, int port, boolean ssl,
  78                         String forwardToHost, int forwardToPort, boolean forwardToSsl)
  79                         throws IOException {
  80                 super(name, port, ssl);
  81                 this.forwardToHost = forwardToHost;
  82                 this.forwardToPort = forwardToPort;
  83                 this.forwardToSsl = forwardToSsl;
  84         }
  85
  86         /**
  87          * The traces handler for this {@link Server}.
  88          * <p>
  89          * The trace levels are handled as follow:
  90          * <ul>
  91          * <li>1: it will only print basic IN/OUT messages with length</li>
  92          * <li>2: it will try to interpret it as an object (SLOW) and print the
  93          * object class if possible</li>
  94          * <li>3: it will try to print the {@link Object#toString()} value, or the
  95          * data if it is not an object</li>
  96          * <li>4: it will also print the unzipped serialised value if it is an
  97          * object</li>
  98          * </ul>
  99          *
 100          * @param tracer
 101          *            the new traces handler
 102          */
 103         @Override
 104         public void setTraceHandler(TraceHandler tracer) {
 105                 super.setTraceHandler(tracer);
 106         }
 107
 108         @Override
 109         protected ConnectActionServer createConnectActionServer(Socket s) {
 110                 return new ConnectActionServerString(s) {
 111                         @Override
 112                         public void action(final Version clientVersion) throws Exception {
 113                                 onClientContact(clientVersion);
 114                                 final ConnectActionServerString bridge = this;
 115
 116                                 new ConnectActionClientString(forwardToHost, forwardToPort,
 117                                                 forwardToSsl, clientVersion) {
 118                                         @Override
 119                                         public void action(final Version serverVersion)
 120                                                         throws Exception {
 121                                                 onServerContact(serverVersion);
 122
 123                                                 for (String fromClient = bridge.rec(); fromClient != null; fromClient = bridge
 124                                                                 .rec()) {
 125                                                         onRec(clientVersion, fromClient);
 126                                                         String fromServer = send(fromClient);
 127                                                         onSend(serverVersion, fromServer);
 128                                                         bridge.send(fromServer);
 129                                                 }
 130                                         }
 131                                 }.connect();
 132                         }
 133                 };
 134         }
 135
 136         /**
 137          * This is the method that is called each time a client contact us.
 138          *
 139          * @param clientVersion
 140          *            the client version
 141          */
 142         protected void onClientContact(Version clientVersion) {
 143                 getTraceHandler().trace("<<< CLIENT " + clientVersion);
 144         }
 145
 146         /**
 147          * This is the method that is called each time a client contact us.
 148          *
 149          * @param serverVersion
 150          *            the server version
 151          */
 152         protected void onServerContact(Version serverVersion) {
 153                 getTraceHandler().trace(">>> SERVER " + serverVersion);
 154         }
 155
 156         /**
 157          * This is the method that is called each time a client contact us.
 158          *
 159          * @param clientVersion
 160          *            the client version
 161          * @param data
 162          *            the data sent by the client
 163          */
 164         protected void onRec(Version clientVersion, String data) {
 165                 trace("<<< CLIENT (" + clientVersion + ")", data);
 166         }
 167
 168         /**
 169          * This is the method that is called each time the forwarded server contact
 170          * us.
 171          *
 172          * @param serverVersion
 173          *            the client version
 174          * @param data
 175          *            the data sent by the client
 176          */
 177         protected void onSend(Version serverVersion, String data) {
 178                 trace(">>> SERVER (" + serverVersion + ")", data);
 179         }
 180
 181         /**
 182          * Trace the data with the given prefix.
 183          *
 184          * @param prefix
 185          *            the prefix (client, server, version...)
 186          * @param data
 187          *            the data to trace
 188          */
 189         private void trace(String prefix, String data) {
 190                 int size = data.length();
 191                 String ssize = size + " byte";
 192                 if (size > 1) {
 193                         ssize = size + " bytes";
 194                         if (size >= 1000) {
 195                                 size = size / 1000;
 196                                 ssize = size + " kb";
 197                                 if (size > 1000) {
 198                                         size = size / 1000;
 199                                         ssize = size + " MB";
 200                                 }
 201                         }
 202                 }
 203
 204                 getTraceHandler().trace(prefix + ": " + ssize, 1);
 205
 206                 if (getTraceHandler().getTraceLevel() >= 2) {
 207                         try {
 208                                 if (data.startsWith("ZIP:")) {
 209                                         data = StringUtils.unzip64(data.substring(4));
 210                                 }
 211
 212                                 Object obj = new Importer().read(data).getValue();
 213                                 if (obj == null) {
 214                                         getTraceHandler().trace("NULL", 2);
 215                                         getTraceHandler().trace("NULL", 3);
 216                                         getTraceHandler().trace("NULL", 4);
 217                                 } else {
 218                                         if (obj.getClass().isArray()) {
 219                                                 getTraceHandler().trace(
 220                                                                 "(" + obj.getClass() + ") with "
 221                                                                                 + Array.getLength(obj) + "element(s)",
 222                                                                 3);
 223                                         } else {
 224                                                 getTraceHandler().trace("(" + obj.getClass() + ")", 2);
 225                                         }
 226                                         getTraceHandler().trace("" + obj.toString(), 3);
 227                                         getTraceHandler().trace(data, 4);
 228                                 }
 229                         } catch (NoSuchMethodException e) {
 230                                 getTraceHandler().trace("(not an object)", 2);
 231                                 getTraceHandler().trace(data, 3);
 232                                 getTraceHandler().trace("", 4);
 233                         } catch (NoSuchFieldException e) {
 234                                 getTraceHandler().trace(
 235                                                 "(object known but incompatible: " + e.getMessage()
 236                                                                 + ")", 2);
 237                                 getTraceHandler().trace(data, 3);
 238                                 getTraceHandler().trace("", 4);
 239                         } catch (ClassNotFoundException e) {
 240                                 getTraceHandler().trace(
 241                                                 "(unknown object: " + e.getMessage() + ")", 2);
 242                                 getTraceHandler().trace(data, 3);
 243                                 getTraceHandler().trace("", 4);
 244                         } catch (Exception e) {
 245                                 getTraceHandler()
 246                                                 .trace("(error when trying to decode: "
 247                                                                 + e.getMessage() + ")", 2);
 248                                 getTraceHandler().trace(data, 3);
 249                                 getTraceHandler().trace("", 4);
 250                         }
 251
 252                         getTraceHandler().trace("", 2);
 253                 }
 254         }
 255
 256         /**
 257          * Start a bridge between 2 servers.
 258          *
 259          * @param args
 260          *            an array containing:
 261          *            <ul>
 262          *            <li>The bridge name</li>
 263          *            <li>The bridge port</li>
 264          *            <li>TRUE for an SSL bridge, FALSE for plain text</li>
 265          *            <li>The forward server host</li>
 266          *            <li>The forward server port</li>
 267          *            <li>TRUE for an SSL forward server, FALSE for plain text</li>
 268          *            <li>(optional) a trace level</li>
 269          *            </ul>
 270          */
 271         public static void main(String[] args) {
 272                 final TraceHandler tracer = new TraceHandler(true, false, 0);
 273                 try {
 274                         if (args.length < 6) {
 275                                 tracer.error("Invalid syntax.\n"
 276                                                 + "Syntax: [name] [port] [ssl] [fhost] [fport] [fssl] ([trace level])\n"
 277                                                 + "\tname: the bridge name\n"
 278                                                 + "\tport: the bridge port\n"
 279                                                 + "\tssl: TRUE for an SSL bridge, FALSE for plain text\n"
 280                                                 + "\tfhost: the forward server host\n"
 281                                                 + "\tfport: the forward server port\n"
 282                                                 + "\tfssl: TRUE for an SSL forward server, FALSE for plain text\n"
 283                                                 + "\ttrace level: the optional trace level (default is 1)\n");
 284                                 return;
 285                         }
 286
 287                         int i = 0;
 288                         String name = args[i++];
 289                         int port = Integer.parseInt(args[i++]);
 290                         boolean ssl = Boolean.parseBoolean(args[i++]);
 291                         String fhost = args[i++];
 292                         int fport = Integer.parseInt(args[i++]);
 293                         boolean fssl = Boolean.parseBoolean(args[i++]);
 294
 295                         int traceLevel = 1;
 296                         if (args.length > 6) {
 297                                 traceLevel = Integer.parseInt(args[i++]);
 298                         }
 299
 300                         ServerBridge bridge = new ServerBridge(name, port, ssl, fhost,
 301                                         fport, fssl);
 302                         bridge.setTraceHandler(new TraceHandler(true, true, traceLevel));
 303                         bridge.run();
 304                 } catch (Exception e) {
 305                         tracer.error(e);
 306                 }
 307         }
 308 }