iotjava/iotrmi/Java/IoTRMIObject.java

   1 package iotrmi.Java;
   2
   3 import java.io.IOException;
   4 import java.nio.ByteBuffer;
   5 import java.util.Arrays;
   6 import java.util.ArrayList;
   7 import java.util.HashMap;
   8 import java.util.List;
   9 import java.util.Map;
  10 import java.util.Set;
  11 import java.lang.reflect.*;
  12
  13
  14 /** Class IoTRMIObject is a class that stores info of an object.
  15  *  <p>
  16  *  It stores object ID, methods, method ID, method's signature
  17  *  and parameters.
  18  *  This class also receive calls from different objects as they
  19  *  ask to execute certain methods remotely. This will have the
  20  *  execution result (return value) sent back to
  21  *
  22  * @author      Rahmadi Trimananda <rtrimana @ uci.edu>
  23  * @version     1.0
  24  * @since       2016-10-03
  25  */
  26 public class IoTRMIObject {
  27
  28         /**
  29          * Class Properties
  30          */
  31         private List<String> listMethodId2Sign; // List of method signature (we use list index as method Id)
  32         private IoTRMIUtil rmiUtil;
  33         private IoTSocketServer rmiServer;
  34         private byte[] methodBytes;
  35
  36
  37         /**
  38          * Constructors
  39          */
  40         public IoTRMIObject(int _port, String[] _methodSign) throws
  41                 ClassNotFoundException, InstantiationException,
  42                         IllegalAccessException, IOException {
  43
  44                 rmiUtil = new IoTRMIUtil();
  45                 listMethodId2Sign = Arrays.asList(_methodSign); // Initialize the method ID list
  46                 methodBytes = null;
  47                 rmiServer = new IoTSocketServer(_port);
  48                 rmiServer.connect();
  49         }
  50
  51
  52         /**
  53          * sendReturnObj() sends back return Object to client
  54          */
  55         public void sendReturnObj(Object retObj) throws IOException {
  56
  57                 // Send back return value
  58                 byte[] retObjBytes = IoTRMIUtil.getObjectBytes(retObj);
  59                 rmiServer.sendBytes(retObjBytes);
  60         }
  61
  62
  63         /**
  64          * getMethodBytes() waits for method transmission in bytes
  65          */
  66         public void getMethodBytes() throws IOException {
  67
  68                 // Receive method info
  69                 methodBytes = rmiServer.receiveBytes(methodBytes);
  70         }
  71
  72
  73         /**
  74          * getSignature() gets method signature from bytes
  75          */
  76         public String getSignature() {
  77
  78                 // Get method Id bytes
  79                 byte[] methodIdBytes = new byte[IoTRMIUtil.METHOD_ID_LEN];
  80                 System.arraycopy(methodBytes, 0, methodIdBytes, 0, IoTRMIUtil.METHOD_ID_LEN);
  81                 // Get method Id
  82                 int methodId = IoTRMIUtil.byteArrayToInt(methodIdBytes);
  83                 // Get method signature from the list
  84                 return listMethodId2Sign.get(methodId);
  85         }
  86
  87
  88         /**
  89          * getMethodParams() gets method params based on byte array received
  90          * <p>
  91          * Basically this is the format of a method in bytes:
  92          * 1) 32-bit value of method ID (hash code)
  93          * 2) m parameters with n-bit value each (m x n-bit)
  94          * For the parameters that don't have definite length,
  95          * we need to extract the length from a preceding 32-bit
  96          * field in front of it.
  97          *
  98          * For primitive objects:
  99          * | 32-bit method ID | m-bit actual data (fixed length)  |
 100          *
 101          * For string, arrays, and non-primitive objects:
 102          * | 32-bit method ID | 32-bit length | n-bit actual data | ...
 103          *
 104          */
 105         public Object[] getMethodParams(Class<?>[] arrCls, Class<?>[] arrGenKeyCls, Class<?>[] arrGenValCls) {
 106
 107                 // Byte scanning position
 108                 int pos = IoTRMIUtil.METHOD_ID_LEN;
 109                 Object[] paramObj = new Object[arrCls.length];
 110                 for (int i=0; i < arrCls.length; i++) {
 111
 112                         String paramType = arrCls[i].getSimpleName();
 113                         int paramSize = rmiUtil.getTypeSize(paramType);
 114                         // Get the 32-bit field in the byte array to get the actual
 115                         //              length (this is a param with indefinite length)
 116                         if (paramSize == -1) {
 117                                 byte[] bytPrmLen = new byte[IoTRMIUtil.PARAM_LEN];
 118                                 System.arraycopy(methodBytes, pos, bytPrmLen, 0, IoTRMIUtil.PARAM_LEN);
 119                                 pos = pos + IoTRMIUtil.PARAM_LEN;
 120                                 paramSize = IoTRMIUtil.byteArrayToInt(bytPrmLen);
 121                         }
 122                         byte[] paramBytes = new byte[paramSize];
 123                         System.arraycopy(methodBytes, pos, paramBytes, 0, paramSize);
 124                         pos = pos + paramSize;
 125                         paramObj[i] = IoTRMIUtil.getParamObject(arrCls[i], arrGenKeyCls[i],
 126                                 arrGenValCls[i], paramBytes);
 127                 }
 128
 129                 return paramObj;
 130         }
 131 }