What it’s all about

This demo is supposed to show a lab-based version of a typical Internet of Things ( IoT )
setup. It follows a 3-Layered architecture of

• Edge: as created of data
• Controller: first level of data processing
• Datacenter: well, the datacenter …

These layers can – and in this demo will – be made out of a set of
Red Hat JBoss products, each taking over an important part in the IoT landscape

What has been implemented?

As for now, this demo includes:

• 1 edge device, which simulates a temperature sensor
• controller functionality to
  • transformation of edge message to a XML format ( not yet needed )
  • route message based on source to be able to apply different procedures
  • complex event processing to filter messages
• datacenter functionality to
  • apply business rules to decide if data is important and needs saving
  • store selected data in a Postgresql database
  • validate data agains business rules and create Human-Task based alert if required
  • provide a graphical business dashboard to see data

Communication between edge and controller, as well as controller internal communication
is implemented via JMS messaging.

Edge Domain

For this demo, I implemented a simple dummy sensor, which can be used to create
data like from a temperature-sensor, pressure-sensor, etc.

As of now, it works with the following steps:

1. start with an initial value ( 70 in this case )
2. send data record via JMS to Controller
3. alter data
   1. get random number between 1 and 1000
   2. if random number is <= 10 reduce data by 1
   3. if random number is >= 990 increase data by 1
4. back to 2.

You can choose if the messages are supposed to be delivered as XML or CSV.

Controller

The controller does the following

1. receive data record via JMS
2. transform data from sensor-specific format to xml, if delivered as CSV
3. route data based on sensor type
4. use complex event processing ( CEP ) to filter messages. Currently we only have one rule, which deletes messages if the value is the same as in the previous message.
5. send data record via JMS to datacenter

Datacenter

As for now, the datacenter is implemented with the following service,
each running in it’s own container

1. receive messages from the controller
2. store the received data in a database ( Postgresql )
3. forward message to a monitor, who checks the data if an alert needs to be raised. This alert is implemented by starting business-process with a human task.
4. provide graphical dashboard to see data

Runtime Environment

The entire functionality is divided into various services, each running in its
own Docker container.

For a detailed instruction on how to install and run the IoT-Demo, please checkout the documentation in my Github Repository