1 package iotruntime.master;
3 import java.util.ArrayList;
4 import java.util.HashMap;
5 import java.util.HashSet;
8 import java.util.Random;
11 /** Class CommunicationHandler is a class that maintains
12 * a data structure that preserves a collection of host name,
13 * port numbers, and objects that are running
14 * +-----------------+----+--------+------------------+--------------+----------------+
15 * | HOST-ADDRESS | ...|IN-PORT | RMIREGISTRY-PORT | RMISTUB-PORT | ACTIVE OBJECTS |
16 * +-----------------+----+--------+------------------+--------------+----------------+
17 * | XXX.XXX.XXX.XXX | | XXXXX | XXXXX | XXXXX | XXXXXXXXXXXXXX |
18 * | | | XXXXX | XXXXX | XXXXX | XXXXXXXXXXXXXX |
19 * | | | XXXXX | XXXXX | XXXXX | XXXXXXXXXXXXXX |
20 * | | ...| ... | ... | ... | ... |
21 * +-----------------+----+--------+------------------+--------------+----------------+
22 * In this case we use ACTIVE OBJECTS names as the key
23 * So ACTIVE OBJECTS maps to numbers and these numbers map to each other
24 * entry in hashmaps (HostAddress can be repetitive)
25 * e.g. ACTIVE OBJECTS ProximitySensorPS0 - 0
26 * ProximitySensorPS1 - 1
29 * IN-PORT / RMIREGISTRY-PORT / RMISTUB-PORT / HOST-ADDRESS: 0 - XXXXX
40 * We add a Set structure to handle all the other ports that are used by devices
41 * when communicating with their respective drivers
43 * @author Rahmadi Trimananda <rahmadi.trimananda @ uci.edu>
47 public final class CommunicationHandler {
50 * CommunicationHandler class properties
52 * Random, host name, port number, active objects
53 * HostAdd is the key to the table so we use it
54 * as a key to elements
55 * HostList gives a mapping from hostname to list of objects
57 private Random random;
58 private List<String> listActiveControllerObj;
59 private List<String> listFieldObjectID;
60 private List<ObjectCreationInfo> listObjCrtInfo;
61 private List<Object[]> listArrFieldValues;
62 private List<Class[]> listArrFieldClasses;
63 private Map<String, Integer> hmActiveObj;
64 private Map<Integer, String> hmHostAdd;
65 private Map<String, ArrayList<String> > hmHostList;
66 private Map<Integer, Integer> hmComPort;
67 private Map<Integer, Integer> hmRMIRegPort;
68 private Map<Integer, Integer> hmRMIStubPort;
69 private Set<Integer> hsDevicePort;
70 private Set<Integer> hsAllPorts;
71 private Map<Integer, Integer> hmAdditionalPort;
72 private int iNumOfObjects;
73 private int iNumOfHosts;
74 private boolean bVerbose;
76 // TODO: THIS IS HACKING FOR IOTSEC
78 private int comPortCount = 10000;
79 private int rmiRegCount = 20000;
80 private int rmiStubCount = 30000;
81 private int additionalCount = 40000;
84 * CommunicationHandler class constants
86 private final int INT_MAX_PORT = 65535;
87 private final int INT_MIN_PORT = 10000;
92 public CommunicationHandler(boolean _bVerbose) {
94 random = new Random();
95 listActiveControllerObj = new ArrayList<String>();
96 listFieldObjectID = new ArrayList<String>();
97 listObjCrtInfo = new ArrayList<ObjectCreationInfo>();
98 listArrFieldValues = new ArrayList<Object[]>();
99 listArrFieldClasses = new ArrayList<Class[]>();
100 hmActiveObj = new HashMap<String, Integer>();
101 hmHostAdd = new HashMap<Integer, String>();
102 hmHostList = new HashMap<String, ArrayList<String>>();
103 hmComPort = new HashMap<Integer, Integer>();
104 hmRMIRegPort = new HashMap<Integer, Integer>();
105 hmRMIStubPort = new HashMap<Integer, Integer>();
106 hsDevicePort = new HashSet<Integer>();
107 hsAllPorts = new HashSet<Integer>();
108 hmAdditionalPort = new HashMap<Integer, Integer>();
111 bVerbose = _bVerbose;
112 RuntimeOutput.print("CommunicationHandler: Creating a new CommunicationHandler object!", bVerbose);
116 * Method clearCommunicationHandler()
118 * Clear the data structure
122 public void clearCommunicationHandler() {
124 listActiveControllerObj.clear();
125 listFieldObjectID.clear();
126 listObjCrtInfo.clear();
127 listArrFieldValues.clear();
128 listArrFieldClasses.clear();
133 hmRMIRegPort.clear();
134 hmRMIStubPort.clear();
135 hsDevicePort.clear();
136 hmAdditionalPort.clear();
139 RuntimeOutput.print("CommunicationHandler: Clearing CommunicationHandler object's data structure!", bVerbose);
143 * Method addPortConnection()
145 * Add a new connection then generate new in-port and out-port numbers
147 * @param sHAddress String host address
148 * @param sAObject String active object name
151 public void addPortConnection(String sHAddress, String sAObject) {
153 // Increment counter first before we add objects as we start from 0
154 // Objects are named uniquely so we record this and match with the host
155 // Hostname occurrence can be repetitive as there can be more than
156 // one host on one compute node
158 // Add a new object in the list of objects
159 hmActiveObj.put(sAObject, iNumOfObjects);
161 // Check host existence in our data structure
162 // Add a new host and a new object
163 if(hmHostList.containsKey(sHAddress) == false) {
165 hmHostList.put(sHAddress, new ArrayList<String>());
167 hmHostList.get(sHAddress).add(sAObject);
169 // Map object to host
170 hmHostAdd.put(iNumOfObjects, sHAddress);
174 iComPort = random.nextInt(INT_MAX_PORT - INT_MIN_PORT + 1) + INT_MIN_PORT;
175 //System.out.println("DEBUG: Assigning comPort: " + comPortCount);
176 //iComPort = comPortCount++;
177 // Check port existence in HashMap
178 } while (portIsAvailable(iComPort) == false);
179 hmComPort.put(iNumOfObjects, iComPort);
180 // hsAllPorts tracks all the existing and used port numbers
181 hsAllPorts.add(iComPort);
185 iRMIRegPort = random.nextInt(INT_MAX_PORT - INT_MIN_PORT + 1) + INT_MIN_PORT;
186 //System.out.println("DEBUG: Assigning regPort: " + rmiRegCount);
187 //iRMIRegPort = rmiRegCount++;
188 // Check port existence in HashMap
189 } while (portIsAvailable(iRMIRegPort) == false);
190 hmRMIRegPort.put(iNumOfObjects, iRMIRegPort);
191 hsAllPorts.add(iRMIRegPort);
193 int iRMIStubPort = 0;
195 iRMIStubPort = random.nextInt(INT_MAX_PORT - INT_MIN_PORT + 1) + INT_MIN_PORT;
196 //System.out.println("DEBUG: Assigning stubPort: " + rmiStubCount);
197 //iRMIStubPort = rmiStubCount++;
198 // Check port existence in HashMap
199 } while (portIsAvailable(iRMIStubPort) == false);
200 hmRMIStubPort.put(iNumOfObjects, iRMIStubPort);
201 hsAllPorts.add(iRMIStubPort);
207 * A private method to add a new active controller object
209 * @params strFieldObjectID String field object ID
210 * @params strObjName String object name
211 * @params strObjClassName String object class name
212 * @params strObjClassInterfaceName String object class interface name
213 * @params strIoTSlaveObjectHostAdd String IoTSlave host address
214 * @params arrFieldValues Array of field values
215 * @params arrFieldClasses Array of field classes
218 public void addActiveControllerObject(String strFieldObjectID, String strObjName, String strObjClassName,
219 String strObjClassInterfaceName, String strObjStubClsIntfaceName, String strIoTSlaveObjectHostAdd, Object[] arrFieldValues,
220 Class[] arrFieldClasses) {
222 listActiveControllerObj.add(strObjName);
223 listFieldObjectID.add(strFieldObjectID);
224 listArrFieldValues.add(arrFieldValues);
225 listArrFieldClasses.add(arrFieldClasses);
226 ObjectCreationInfo objCrtInfo = new ObjectCreationInfo(strIoTSlaveObjectHostAdd, strObjName,
227 strObjClassName, strObjClassInterfaceName, strObjStubClsIntfaceName);
228 listObjCrtInfo.add(objCrtInfo);
232 * Method addDevicePort()
234 * Add a port that is used by a device when communicating with its driver
235 * This port will be taken into account when checking for port availability
237 * @param iDevPort Device port number
240 public void addDevicePort(int iDevPort) {
242 hsDevicePort.add(iDevPort);
243 // Track this port number
244 hsAllPorts.add(iDevPort);
248 * Method addAdditionalPort()
250 * Add a new port for new connections for any objects in the program.
251 * This newly generated port number will be recorded.
253 * @return int One new port
255 public int addAdditionalPort(String sAObject) {
257 hmActiveObj.put(sAObject, iNumOfObjects);
259 int iAdditionalPort = 0;
261 iAdditionalPort = random.nextInt(INT_MAX_PORT - INT_MIN_PORT + 1) + INT_MIN_PORT;
262 //System.out.println("DEBUG: Assigning additionalPort: " + additionalCount);
263 //iAdditionalPort = additionalCount++;
264 // Check port existence in HashMap
265 } while (portIsAvailable(iAdditionalPort) == false);
266 hmAdditionalPort.put(iNumOfObjects, iAdditionalPort);
267 // Track this port number
268 hsAllPorts.add(iAdditionalPort);
272 return iAdditionalPort;
276 * Method portIsAvailable()
278 * Checks the availability of the newly generated port.
279 * If port number has been used in any of the lists then
280 * it is not available
282 * @param iPortNumber Device port number
285 public boolean portIsAvailable(int iPortNumber) {
287 if (hmComPort.containsValue(iPortNumber) == true) {
289 } else if (hmRMIRegPort.containsValue(iPortNumber) == true) {
291 } else if (hmRMIStubPort.containsValue(iPortNumber) == true) {
293 } else if (hmAdditionalPort.containsValue(iPortNumber) == true) {
295 } else if (hsDevicePort.contains(iPortNumber) == true) {
300 //if (hsAllPorts.contains(iPortNumber)) {
308 * Method getNumOfObjects()
312 public int getNumOfObjects() {
314 return iNumOfObjects;
319 * Method getNumOfHosts()
323 public int getNumOfHosts() {
330 * Method objectExists()
332 * @param sObjName String object name
335 public boolean objectExists(String sObjName) {
337 return hmActiveObj.containsKey(sObjName);
342 * Method hostExists()
344 * @param sHostName String host name
347 public boolean hostExists(String sHostName) {
349 return hmHostList.containsKey(sHostName);
354 * Method getHostAddress()
356 * User finds HostAddress using Object name
358 * @param sAObject String active object name
361 public String getHostAddress(String sAObject) {
363 return hmHostAdd.get(hmActiveObj.get(sAObject));
370 * User gets the set of hostnames
374 public Set<String> getHosts() {
376 return hmHostList.keySet();
381 * Method getComPort()
383 * User finds In-Port number using Object name
385 * @param sAObject String active object name
388 public Integer getComPort(String sAObject) {
390 return hmComPort.get(hmActiveObj.get(sAObject));
394 * Method getAdditionalPort()
396 * User finds a port number using Object name
398 * @param sAObject String active object name
401 public Integer getAdditionalPort(String sAObject) {
403 return hmAdditionalPort.get(hmActiveObj.get(sAObject));
407 * Method getRMIRegPort()
409 * User finds Out-Port number using Object name
411 * @param sAObject String active object name
414 public Integer getRMIRegPort(String sAObject) {
416 return hmRMIRegPort.get(hmActiveObj.get(sAObject));
421 * Method getRMIStubPort()
423 * User finds Out-Port number using Object name
425 * @param sAObject String active object name
428 public Integer getRMIStubPort(String sAObject) {
430 return hmRMIStubPort.get(hmActiveObj.get(sAObject));
435 * Method getFieldObjectID()
437 * User finds field object ID using Object name
439 * @param sAObject String active object name
442 public String getFieldObjectID(String sAObject) {
444 return listFieldObjectID.get(listActiveControllerObj.indexOf(sAObject));
449 * Method getObjectCreationInfo()
451 * User finds ObjectCreationInfo using Object name
453 * @param sAObject String active object name
454 * @return ObjectCreationInfo
456 public ObjectCreationInfo getObjectCreationInfo(String sAObject) {
458 return listObjCrtInfo.get(listActiveControllerObj.indexOf(sAObject));
463 * Method getArrayFieldClasses()
465 * User finds array of field classes using Object name
467 * @param sAObject String active object name
470 public Class[] getArrayFieldClasses(String sAObject) {
472 return listArrFieldClasses.get(listActiveControllerObj.indexOf(sAObject));
477 * Method getArrayFieldValues()
479 * User finds array of field values using Object name
481 * @param sAObject String active object name
484 public Object[] getArrayFieldValues(String sAObject) {
486 return listArrFieldValues.get(listActiveControllerObj.indexOf(sAObject));
491 * Method getActiveControllerObjectList()
493 * @return List<String>
495 public List<String> getActiveControllerObjectList() {
497 return listActiveControllerObj;
502 * Method printLists()
506 public void printLists() {
508 // Iterate on HostAddress
509 for(String s : hmHostList.keySet()) {
511 for(String str : hmHostList.get(s)) {
513 int iIndex = hmActiveObj.get(str);
514 RuntimeOutput.print("Active Object: " + str, bVerbose);
515 RuntimeOutput.print("Communication Port: " + hmComPort.get(iIndex), bVerbose);
516 RuntimeOutput.print("RMI Registry Port: " + hmRMIRegPort.get(iIndex), bVerbose);
517 RuntimeOutput.print("RMI Stub Port: " + hmRMIStubPort.get(iIndex), bVerbose);
518 RuntimeOutput.print("\n", bVerbose);
522 for(int iPort : hsDevicePort) {
523 RuntimeOutput.print("Device Port: " + iPort, bVerbose);
525 RuntimeOutput.print("\n", bVerbose);