Modifying master for Tomoyo process jailing; Adding basic policies for Tomoyo environment for SmartLightsController

Adding a simple script to register a new device (MAC, IP, key, and device name)

Updating database

Updating the fourth benchmark with new stubs/skeletons; it is probably better to separate the interface for the 3 SmartThings sensors

Updating the third benchmark with new stubs and skeletons

Updating stubs and skeletons for the second benchmark and drivers; tested the second benchmark!

Removing callback port feature from master and slave

New .so file for LifxLightBulb

Adding object ID tracking for simultaneous generation of stubs/skeletons (e.g. for one benchmark); Fixing a few small bugs in compiler

Reverting back the first benchmark (now works with less threads); synchronization problems with too many threads with arbitrary calls of callbacks at times

Updating the first benchmark with new stubs/skeletons; somehow motion detection is not working properly although the whole transport layer works fine; suspecting that multi-threading doesn't give much chance to motion detection thread

Migrating PhoneInterface (Irrigation and SpeakerLocator) from old to new Nexus 5X phone

Updating skeletons and stubs for C++; Fixing one bug in IoTCompiler for C++ skeleton instantiation code; Need to find workaround for multithreading on ARM (cross compiler doesn't work)

Updating stub and skeleton for Lifxtest

Updating database once more; Zigbee gateway address for Smartthings sensors

Merging multiple versions of Xbee python driver

Renewing MySQL database backup; Moving Zigbee gateway to RaspberryPi #4

Python Zigbee module installer

Fixing a bug in IoTMaster (wrong variable for language flag check); adding LANGUAGE field in controller config file

Adding flags to master to give flexibility to choose between C++ and Java for every device driver and controller

Making sure that C++ Set and Relation methods return pointers from a new set/map every time the method is called; this keeps the original set/map intact/immutable.

Adding Java Checker Framework checker option in the makefiles; basically this is just to check and flag error when there is java.net/java.lang.reflect usage in user's code

Adding Java Checker Framework to flag error when java.net and java.lang.reflect libraries are used in user's code

Restoring IoTRMICall and IoTRMIObject to their original states for the sake of compiling current benchmarks (these two are deprecated and will soon not be used at all)

Making sure that compiler can generate methods with multiple callbacks with different types

Fixing bugs for multiple callback inputs; adding more testcases

Minor tests for multiple callbacks, enum, and struct for both Java and C++; Fixing small bugs in compiler and RMI client

Fixed compiler for Java code generation (not heavily tested yet, but fixes include return value generation, enum, and struct handling)

Tested C++ RPS/RMI libraries for arbitrary objects and arbitrary remote calls

Cleaning up error messages, etc. in Java RMI part

Changing IoTRMIComm into abstract and refactoring into Client and Server parts

First version of skeleton-stub communication using queue and 2 sockets (one send and one receive) as this involves multi-threading and Java socket is NOT thread safegit status!

Creating ConcurrentLinkedListQueue for C++

Preparing C++ stubs and skeletons for circular compilation (it couldn't compile earlier)

Working Java v.1.0 for arbitrary calls of callback objects

Working C++ IoTSlave for both IoTSet and IoTRelation; threading works for C++ LifxLightBulb driver in x86_64 binary but not in ARM version

Adding class LabRoom for IoTRelation testing with C++ IoTSlave

Modified and tested IoTMaster for IoTSet in C++; completed IoTMaster and IoTSlave.cpp for IoTRelation as well but untested

Adding C++ field instrumentation using config file

Perfecting IoTSlave for C++; Found one issue with SSH/Java process execution in which process is killed if we print something through cout in the C++ program

Adding stub and skeleton for Lifxtest and LifxLightBulb; Creating build flow for shared-objects; Developing IoTSlave for C++

Changing a few things to pointer; Testing Lifxtest benchmark without using runtime system

Preparing Lifxtest as a test benchmark; making adjustments in IoTSet for C++, etc.

Separating implementations from declarations for LifxLightBulb

Fixing 2 issues in LifxLightBulb driver: 1) Detached thread handling (need to pass in this pointer for proper class method calls); 2) Extending socket library to have set timeout capability to create non-blocking UDP socket

Adding debug messages on slave to print info for designing C++ slave part

Creating new directory for all Java benchmarks

Minor fixes in LifxLightBulb driver (not fully tested yet)

Moving Java drivers; Creating iotruntime socket connections for C++; First version of LifxLightBulb driver in C++

Replacing default BUFFSIZE value with new buffer size value when a resize needs to happen

Backing up database

Adding a (potential) initialization for Alarm; Modifying IoTSocket to allocate a larger byte buffer array when needed

Perfecting 4th benchmark; adding needed MySQL config files; maturing Zigbee drivers

Fixing MySQL query parsing bug for IoTRelation; adjusting MySQL queries for new interfaces; backing up database

Adjusting files in ZigbeeTest; preparing things for 4th benchmark, i.e. generating stubs and skeletons, fixing code, checking in mysql config files, etc.

Adding xbee_driver Python files

Adjustments to ZigbeeTest and Python files to use just 1 port for shooting Zigbee protocol rules

Testing Smartthings sensors with some adjustments for 4th benchmark

Adding missing stub and skeleton files for 3rd benchmark; Increasing incoming buffer size for IoTSocket to 8MB as needed by IHome speaker; completing 2nd and 3rd benchmark porting

Adding missing files, completing driver config files with stub interface, completing build flow with .jks file for https

Updating database

Preparing 3rd benchmark for porting with capability-based RMI

Preparing files, stubs, and skeletons for 2nd benchmark

Applying changes for 3rd benchmark (wildcard addresses) in IoTMaster

Adding new policies for stub/skeleton generation - second benchmark

Updating database with relations; Adding new SQL query config files

Updating database for the 4th benchmark

Removing unwanted stub and skeleton files

Preparing second and third benchmarks; backing up MySQL database

First benchmark working with capability-based RMI; adjustments in callbacks, etc.

Adjustments in stubs and skeletons for callback in callback; using different ports for each for now; still having problems with cross references in C++

Porting and compiling SmartLightsController

Integrating capability-based RMI on Sentinel for Java side

Preparing Makefiles, stub, skeleton, config files, etc. for porting LifxLightBulb and Lifxtest

Adding LifxLightBulb files and placeholders for benchmarks; preparing for porting

Adding last version of iotruntime and iotinstaller; preparing to extend IoTMaster for new RMI

Cleaning up

Adding example for a CPP that calls class skeleton

Adding example for a CPP that calls class skeleton

Tested on RPi, both RPi1 and RPi2; works fine and fast

1) Making Java socket read/write length in 4 bytes as well; 2) Fixing endianness issue when transferring message length between Java and C++

Fixing a bug in C++ socket server-client: message length was represented just in 1 byte - this is not enough for sending longer messages (just enough to represent up to ~126 bytes/8-bit representation) - now it's changed to 4 bytes (integer size)

Testing enum and callback combination

Combining enum, struct, and callback in one method; refactoring method body generations for callback and non-callback methods; fixing small bugs

Integrating enum and struct in one method call; fixing minor bugs

Testing complex callbacks invocation; fixing subtle bugs

Testing more complex struct and enum declarations; fixing subtle bugs

Fixing second bug (C++ skeleton cannot connect to Java's callback socket server); Instead of reporting connection failure after the first connection, we make the C++ wait for connection to occur (Java thread/socket server creation is a little slower)

Fixing problem with array/list of callbacks; Java static variables persist across multiple objects of the same type that are instantiated at the same instance - needed to make objectId non-static to mark different callback objects

Testing callbacks for Java and C++; fixing a few bugs; more bugs to tackle: 1) Need to retest C++ skeleton and Java stub, 2) Array of callbacks contains wrong references in Java

Testing struct for array and list (Java and C++); fixing bugs

Testing struct (single object); fixing small bugs, etc.

Fixing bugs: 1) Arrays.asList generates finaled List (need to feed it into an ArrayList constructor); 2) Generate setAllowed.insert() only when there is callback for C++

Testing and fixing bugs on enum data types

Adding permission insertion for struct (will be tested later)

Moving permission setting from stub to skeleton (mistakenly put stuff in stub and not skeleton)

Adding permission inclusion for callback helper function; some testcases on enum type

Cleaning up callback code generation; Fixing a few minor issues, e.g. indentation, etc.

Preparing for callback testing (creating new policy files); Adding error messsages that require callback policy files (with class definition) to be parsed first

Testing for list/vector data types