def _on_register(self):
# create the actuator container as a base
self.actuator_cnt = Container(resourceName='actuator',
maxNrOfInstances=5)
# attach the actuator container to the ActuatorExample base path
self.actuator = self.create_container(None, self.actuator_cnt)
# now create a data_in container for actuator input
self.data_in_cnt = Container(resourceName='data_in',
maxNrOfInstances=5)
# attach the data_in container below the actuator
# data_in path is onem2m/ActuatorExample/actuator/data_in
self.data_in = self.create_container(self.actuator, self.data_in_cnt)
# create a data_out container for the actuator output
self.data_out_cnt = Container(resourceName='data_out',
maxNrOfInstances=5)
# attach the data_out container below the actuaor
# data_out path is onem2m/ActuatorExample/actuator/data_out
self.data_out = self.create_container(self.actuator, self.data_out_cnt)
# subscribe to the data_in container because that's how actuator will be notified
self.add_container_subscription(self.data_in,
self.handle_actuator_data_in)
# subscribe to the data_out container because we can check if the actuator did infact behave
# as we like it to. As soon as we push something, we will be notified.
self.add_container_subscription(self.data_out,
self.handle_actuator_data_out)
# start endless loop
# we want actuator to run forever
self.run_forever()
def _push_content(self, dev_id, data_type, val):
val_cnt_id = val['type']
val_id = dev_id + ":" + data_type + ":" + val_cnt_id
try:
val_cnt = self.containers[val_id]
except KeyError:
data_id = dev_id + ":" + data_type
try:
data_cnt = self.containers[data_id]
except KeyError:
dev_cnt = self.containers[dev_id]
data_cnt = Container(resourceName=data_type,
maxNrOfInstances=0)
data_cnt = self.create_container(dev_cnt, data_cnt)
self.containers[data_id] = data_cnt
val_labels = [
"openmtc:%s" % data_type,
"openmtc:%s:%s" % (data_type, val_cnt_id)
]
val_cnt = Container(resourceName=val_cnt_id, labels=val_labels)
val_cnt = self.create_container(data_cnt, val_cnt)
self.containers[val_id] = val_cnt
con = self._get_unified_data(dev_id, val)
self.logger.debug("Pushing content instance %s for id %s", con, val_id)
self.push_content(val_cnt, con)
def create_sensor_structure(self, sensor):
print('initializing sensor: %s' % sensor)
# create sensor container
device_container = Container(resourceName=sensor)
device_container = self.create_container(self._devices_container.path,
device_container,
labels=['sensor'],
max_nr_of_instances=0)
# add sensor to _recognized_sensors
self._recognized_sensors[sensor] = device_container
# create measurements container
labels = ['measurements']
if sensor.startswith('Temp'):
labels.append('temperature')
else:
labels.append('humidity')
measurements_container = Container(resourceName='measurements')
measurements_container = self.create_container(device_container.path,
measurements_container,
labels=labels,
max_nr_of_instances=3)
# add measurements_container from sensor to _recognized_measurement_containers
self._recognized_measurement_containers[sensor] = measurements_container
def _on_register(self):
# create a request channel
self.request_cnt = Container(
resourceName='request',
labels=['elastest:actuator:simple:request'],
maxNrOfInstances=5)
self.request_cnt = self.create_container(None, self.request_cnt)
# subscribe to the request channel
self.add_container_subscription(self.request_cnt, self.handle_request)
# create response channel
self.response_cnt = Container(
resourceName='response',
labels=['elastest:actuator:simple:response'],
maxNrOfInstances=5)
self.response_cnt = self.create_container(None, self.response_cnt)
# create status channel
self.status_cnt = Container(resourceName='status',
labels=['elastest:actuator:simple:status'],
maxNrOfInstances=5)
self.status_cnt = self.create_container(None, self.status_cnt)
# start endless loop
self.run_forever()
def _on_register(self):
# create the channels for orch by creating respective containers
# first create orch container
self.orch_cnt = Container(resourceName='edsorch',
labels=['elastest:edsorch'],
maxNrOfInstances=1)
self.orch_cnt = self.create_container(None, self.orch_cnt)
#create request container
self.request_cnt = Container(resourceName='request',
labels=['elastest:edsorch:request'],
maxNrOfInstances=1)
self.request_cnt = self.create_container(self.orch_cnt,
self.request_cnt)
self.add_container_container_subscription(self.request_cnt,
self._handle_request)
# create response container
self.response_cnt = Container(resourceName='response',
labels=['elastest:edsorch:response'],
maxNrOfInstances=1)
self.response_cnt = self.create_container(self.orch_cnt,
self.response_cnt)
# create status container
self.status_cnt = Container(resourceName='status',
labels=['elastest:edsorch:status'],
maxNrOfInstances=1)
self.status_cnt = self.create_container(self.orch_cnt,
self.status_cnt)
# start endless loop
self.run_forever()
def _on_register(self):
# init variables
self._recognized_sensors = {}
self._recognized_measurement_containers = {}
self._command_containers = {}
# init base structure
label = 'devices'
container = Container(resourceName=label)
self._devices_container = self.create_container(None,
container,
labels=[label],
max_nr_of_instances=0)
# create container for each actuator
for actuator in self.actuators:
actuator_container = Container(resourceName=actuator)
self.create_container(
self._devices_container.path, # the target resource/path parenting the Container
actuator_container, # the Container resource or a valid container ID
max_nr_of_instances=0, # the container's max_nr_of_instances (here: 0=unlimited)
labels=['actuator'] # (optional) the container's labels
)
# trigger periodically new data generation
self.run_forever(1, self.get_random_data)
# log message
self.logger.debug('registered')
def add_sensor_method(self, path, name):
# containers on the given attach path
sensor_name = name
sensor_cnt = Container(resourceName=sensor_name,
labels=['elastest:sensor:humidity'],
maxNrOfInstances=1)
sensor_cnt = self.create_container(path, sensor_cnt)
# create a data container on top of sensor container
data_cnt = Container(resourceName='data',
labels=['elastest:sensor:humidity:data'],
maxNrOfInstances=5)
data_cnt = self.create_container(sensor_cnt, data_cnt)
# create a class method to update sensor values
def add_update_method(func, name):
conf = self.registered_sensors[name]
data = uniform(float(conf['min']), float(conf['max']))
if not conf['shutdown']:
gevent.spawn_later(float(conf['period']), func, func, name)
if conf['onoff'] == 'ON':
self.push_content(data_cnt, str(data))
add_update_method.__name__ = str(sensor_name + '_func')
setattr(self, add_update_method.__name__, add_update_method)
funcname = sensor_name + '_func'
sensorfunc = getattr(self, funcname)
self.registered_sensors[sensor_name]['path'] = data_cnt.path
self.registered_sensors[sensor_name]['name'] = sensor_name
#self.call_timer(sensorfunc, name)
sensorfunc(sensorfunc, name)
def add_device(self, cnt_id, labels, sub_containers):
labels += ["openmtc:device", "openmtc:device:cul868"]
dev_cnt = Container(resourceName=cnt_id,
maxNrOfInstances=0,
labels=labels)
dev_cnt = self.create_container(None, dev_cnt)
self.dev_containers[cnt_id] = dev_cnt
dev_id = self.device_mappings.get(cnt_id, cnt_id)
for c_id, l, func in sub_containers:
s_id = cnt_id + '_' + c_id.upper()
sub_labels = ['openmtc:id:%s/%s/%s' % (self._cse_id, dev_id, c_id)]
if func:
sub_labels.append('openmtc:actuator_data')
sub_labels += map(lambda x: "openmtc:actuator_data:%s" % x,
l) if l else []
sub_cnt = Container(resourceName=c_id,
maxNrOfInstances=0,
labels=sub_labels)
else:
sub_labels.append('openmtc:sensor_data')
sub_labels += map(lambda x: "openmtc:sensor_data:%s" % x,
l) if l else []
sub_cnt = Container(resourceName=c_id, labels=sub_labels)
self.containers[s_id] = s_cnt = self.create_container(
dev_cnt, sub_cnt)
if func:
self.add_container_subscription(s_cnt, func)
return dev_cnt
def add_device(self, cnt_id, labels, sub_containers):
labels += ["openmtc:device", "openmtc:device:cul868"]
cse_id = self.get_resource(self.cse_base).CSE_ID[1:]
try:
tenant_id, instance_id = cse_id.split('~')
except ValueError:
tenant_id = cse_id
instance_id = 'None'
context = (self.device_mappings[cnt_id]
if cnt_id in self.device_mappings.keys() else None)
dev_cnt = Container(resourceName=cnt_id,
maxNrOfInstances=0,
labels=labels)
dev_cnt = self.create_container(None, dev_cnt)
self.dev_containers[cnt_id] = dev_cnt
for c_id, l, func in sub_containers:
s_id = cnt_id + '_' + c_id.upper()
if func:
l = (map(lambda x: "openmtc:actuator_data:%s" % x, l)
if l else [])
l.append('openmtc:actuator_data')
l.append('openmtc:sensor_data')
# if in device mappings, add smart orchestra labels
if context:
l.extend(
('{}'.format(tenant_id),
'{}/{}'.format(tenant_id, instance_id),
'{}/{}/{}'.format(tenant_id, instance_id, context),
'{}/{}/{}/{}'.format(tenant_id, instance_id, context,
c_id)))
sub_cnt = Container(resourceName=c_id,
maxNrOfInstances=0,
labels=l)
else:
l = map(lambda x: "openmtc:sensor_data:%s" % x, l) if l else []
l.append('openmtc:actuator_data')
l.append('openmtc:sensor_data')
# if in device mappings, add smart orchestra labels
if context:
l.extend(
('{}'.format(tenant_id),
'{}/{}'.format(tenant_id, instance_id),
'{}/{}/{}'.format(tenant_id, instance_id, context),
'{}/{}/{}/{}'.format(tenant_id, instance_id, context,
c_id)))
sub_cnt = Container(resourceName=c_id, labels=l)
self.containers[s_id] = s_cnt = self.create_container(
dev_cnt, sub_cnt)
if func:
self.add_container_subscription(s_cnt, func)
return dev_cnt
def handle_register_application(self, request):
# check if application name is already registered
app_ID = str(request['register']['application']['app_ID'])
request_ID = str(request['register']['application']['request_ID'])
if app_ID in self.registered_apps:
result = 'FAIL'
error_string = 'app_ID already registered with orchestrator'
reply = {
'result': result,
'request_ID': request_ID,
'response': {},
'error_string': error_string
}
self.push_content(self.response_cnt, reply)
# request format
# {'register' : {'application' : {'app_ID':'uuid', 'request_ID': 'uuid'}}}
label = 'elastest:application'
# create a container with the name of app_ID
app_cnt = Container(resourceName=app_ID,
labels=[label],
maxNrOfInstances=1)
app_cnt = self.create_container(None, app_cnt)
label = label + ':sensors'
# create a sensors container
sensors_cnt = Container(resourceName='sensors',
labels=[label],
maxNrOfInstances=1)
sensors_cnt = self.create_container(app_cnt, sensors_cnt)
# create an actuators container
label = 'elastest:application:actuators'
actuators_cnt = Container(resourceName='actuators',
labels=[label],
maxNrOfInstances=1)
actuators_cnt = self.create_container(app_cnt, actuators_cnt)
# attach containers for future possible types of actuators
# reply format
# {'request_ID': 'uuid', 'result': 'SUCCESS', 'conf': dict(conf),
# 'error': 'error_string'}
result = 'SUCCESS'
error_string = ''
conf = {'path': app_cnt.path}
reply = {
'request_ID': request_ID,
'result': result,
'conf': conf,
'error_string': error_string
}
self.registered_apps[app_ID] = {
'path': app_cnt.path,
'sensors': [],
'actuators': []
}
self.push_content(self.response_cnt, reply)
def create_server_structure(self): self.data_ae = self.create_application(AE(resourceName='sensor_data'), self.remote_cse) for sensor in self.sensors: container = Container(resourceName=sensor) data_container = self.create_container(self.data_ae.path, container, labels=sensor, max_nr_of_instances=10) self._registered_sensors[sensor] = data_container
def create_sensor_structure(self, sensor_entry, content):
# dev_cnt
cnt_name = '_'.join(content[0]['bn'].split(':')[2:])
cnt_name += '_' + content[0]['n']
dev_cnt = Container(resourceName=cnt_name)
if dev_cnt not in self.dev_cnt_list:
sensor_entry['dev_cnt'] = dev_cnt = self.create_container(None, dev_cnt)
# mean cnt
mean_cnt = Container(resourceName='mean', labels=["openmtc:mean_data"])
sensor_entry['mean_cnt'] = self.create_container(dev_cnt, mean_cnt)
# Standard_deviation cnt
deviation_cnt = Container(resourceName='Standard_deviation', labels=["openmtc:Standard_deviation_data"])
sensor_entry['deviation_cnt'] = self.create_container(dev_cnt, deviation_cnt)
self.dev_cnt_list.append(dev_cnt)
else:
return dev_cnt,"already exists "
def _on_register(self):
# init variables
self._recognized_sensors = {}
self._recognized_measurement_containers = {}
self._command_containers = {}
# init base structure
label = 'devices'
container = Container(resourceName=label)
self._devices_container = self.create_container(None,
container,
labels=[label],
max_nr_of_instances=0)
# create container for each actuator
for actuator in self.actuators:
actuator_container = Container(resourceName=actuator)
self.create_container(
self._devices_container.
path, # the target resource/path parenting the Container
actuator_container, # the Container resource or a valid container ID
max_nr_of_instances=
0, # the container's max_nr_of_instances (here: 0=unlimited)
labels=['actuator'] # (optional) the container's labels
)
# create container for the commands of the actuators
commands_container = Container(resourceName='commands')
commands_container = self.create_container(actuator_container.path,
commands_container,
max_nr_of_instances=3,
labels=['commands'])
# add commands_container of current actuator to self._command_containers
self._command_containers[actuator] = commands_container
# subscribe to command container of each actuator to the handler command
self.add_container_subscription(
commands_container.
path, # the Container or it's path to be subscribed
self.
handle_command # reference of the notification handling function
)
# trigger periodically new data generation
self.run_forever(1, self.get_random_data)
# log message
self.logger.debug('registered')
def create_container(self,
target,
container,
labels=None,
max_nr_of_instances=None):
""" Creates a Container resource.
:param target: the target resource/path parenting the Container
:param container: the Container resource or a valid container ID
:param labels: (optional) the container's labels
:param max_nr_of_instances: (optional) the container's maximum number
of instances (0=unlimited)
"""
def restore_container(c):
self.logger.warn("Restoring container: %s", c.path)
c.expirationTime = None
self.__known_containers.remove(c.path)
self.create_container(target, c, labels=labels)
if target is None:
target = self.__app
if not isinstance(container, Container):
container = Container(resourceName=container)
# if we got max instances..set them
if max_nr_of_instances:
container.maxNrOfInstances = max_nr_of_instances
# if we did not set max instances yet, set them
else:
container.maxNrOfInstances = self.max_nr_of_instances
if container.expirationTime is None:
container.expirationTime = self.get_expiration_time()
if labels:
container.labels = labels
path = getattr(target, "path", target)
try:
container = self.mapper.create(path, container)
except OneM2MErrorResponse as error_response:
if error_response.response_status_code is STATUS_CONFLICT:
c_path = path + '/' + container.resourceName
container.path = c_path
if (self.__resumed_registration
and c_path not in self.__known_containers):
container = self.mapper.update(container)
else:
raise error_response
else:
raise error_response
self.__known_containers.add(container.path)
self.__start_refresher(container, restore=restore_container)
self.logger.info("Container created: %s." % (container.path, ))
return container
def _on_register(self):
# create a sensor container with 5 instances history
self.sensor_cnt = Container(resourceName='sensor', maxNrOfInstances=5)
# attach the sensor container to the SensorExample base path
# this container is now accessible under path "onem2m/SensorExample/sensor"
self.sensor = self.create_container(None, self.sensor_cnt)
# now create another container called data container which will hold the data
# values sent by the container with max history of 5 instances
self.data_cnt = Container(resourceName='data', maxNrOfInstances=5)
# attach this container next to sensor
# data container is accessible by
# onem2m/SensorExample/sensor/data
self.data = self.create_container(self.sensor, self.data_cnt)
# register a handler to check if you actually send data
self.add_container_subscription(self.data, self.handle_sensor_data)
# call a periodic function which pumps sensor data into the data container
self.generate_send_data()
def _create_measurement_container(self, device_name, name):
measurement_container = self.create_container(
self._recognized_sensors[device_name].path,
Container(resourceName=name),
max_nr_of_instances=0,
labels=[
'openmtc:sensor_data:{}'.format(name), 'openmtc:sensor_data'
])
self._recognized_measurement_containers[device_name][
name] = measurement_container
def _on_register(self):
self.logger.info("Starting Coordinator...")
cnt = Container(resourceName='devices', maxNrOfInstances=0)
self.devices_container = self.create_container(None, cnt)
self.coordinator.add_handler('REGISTER_DEVICE', self._register_device)
if self.sim:
self.coordinator.start_simulation(self.run_forever,
self.sim_period)
else:
self.coordinator.start()
def container_builder(self, res):
container = Container(resourceName=res.resourceName,
resourceType=res.resourceType,
resourceID=res.resourceID,
parentID=res.parentID,
lastModifiedTime=res.lastModifiedTime,
creationTime=res.creationTime,
currentNrOfInstances=res.currentNrOfInstances)
#self.print_resource(res)
return container
def _handle_device_data(self, data, dev_id):
dev_cnt = self.containers[dev_id]
cnt_id = dev_id + ":device_data"
try:
cnt = self.containers[cnt_id]
except KeyError:
cnt = Container(resourceName='device_data', maxNrOfInstances=1)
self.containers[cnt_id] = cnt = self.create_container(dev_cnt, cnt)
self.push_content(cnt, data)
def _create_base_label_container(self):
label = 'sensor_data'
container = Container(resourceName=label)
self._sensor_data_container = self.create_container(
None,
container,
labels=[label, "openmtc:device"],
max_nr_of_instances=10)
self._single_sensor_map = {}
for sensor in ["x", "y", "z"]:
_labels = [
"openmtc:sensor_data",
"openmtc:sensor_data:%s" % sensor
]
_container = Container(resourceName=sensor)
_single_sensor_container = self.create_container(
self._sensor_data_container.path,
_container,
labels=_labels,
max_nr_of_instances=3)
self._single_sensor_map[sensor] = _single_sensor_container
def create_sensor_structure(self, sensor):
print('initializing sensor: %s' % sensor)
# create sensor container
device_container = Container(resourceName=sensor)
device_container = self.create_container(self._devices_container.path,
device_container,
labels=['sensor'],
max_nr_of_instances=0)
# add sensor to _recognized_sensors
self._recognized_sensors[sensor] = device_container
def _register_device(self, nid, actuator_data=None):
self.logger.debug("Registering device...")
# create the main container for the device
device_container = self._create_device_container(nid)
self.containers[nid] = device_container
if actuator_data:
cnt = Container(resourceName='actuator_data', maxNrOfInstances=0)
cnt = self.create_container(device_container, cnt)
for actuator in actuator_data:
labels = [
"openmtc:actuator_data",
"openmtc:actuator_data:%s" % actuator
]
actuator_cnt = Container(resourceName=actuator,
maxNrOfInstances=1,
labels=labels)
actuator_cnt = self.create_container(cnt, actuator_cnt)
self.add_container_subscription(actuator_cnt,
self._handle_zbs110_switch)
self.subscriptions[actuator_cnt.path] = nid
def example_init(self):
self._recognized_sensors = {}
self._recognized_measurement_containers = {}
self._command_containers = {}
label = 'devices'
container = Container(resourceName=label)
self._devices_container = self.create_container(None,
container,
labels=[label],
max_nr_of_instances=0)
# create container for each actuator
for actuator in self.actuators:
actuator_container = Container(resourceName=actuator)
self.create_container(
self._devices_container.
path, # the target resource/path parenting the Container
actuator_container, # the Container resource or a valid container ID
max_nr_of_instances=
0, # the container's max_nr_of_instances (here: 0=unlimited)
labels=['actuator'] # (optional) the container's labels
)
# create container for the commands of the actuators
commands_container = Container(resourceName='commands')
commands_container = self.create_container(actuator_container.path,
commands_container,
max_nr_of_instances=0,
labels=['commands'])
# add commands_container of current actuator to self._command_containers
self._command_containers[actuator] = commands_container
#self.subscribe to command container of each actuator to the handler command
self.add_container_subscription(
commands_container.
path, # the Container or it's path to be subscribed
self.
handle_cin_creation # reference of the notification handling function
)
def _on_register(self):
# init base structure
label = 'devices'
container = Container(resourceName=label)
self._devices_container = self.create_container(None,
container,
labels=[label],
max_nr_of_instances=0)
# trigger periodically new data generation
self.run_forever(1, self.get_random_data)
# log message
self.logger.debug('registered')
def add_actuator(self, path, name):
# containers on the given attach path
actuator_name = name
actuator_cnt = Container(resourceName=actuator_name,
labels=['elastest:actuator:simple'],
maxNrOfInstances=1)
actuator_cnt = self.create_container(path, actuator_cnt)
# create data in and data our containers
data_in_cnt = Container(resourceName='data_in',
labels=['elastest:actuator:simple:data_in'],
maxNrOfInstances=5)
data_in_cnt = self.create_container(actuator_cnt, data_in_cnt)
data_out_cnt = Container(resourceName='data_out',
labels=['elastest:actuator:simple:data_out'],
maxNrOfInstances=5)
data_out_cnt = self.create_container(actuator_cnt, data_out_cnt)
def add_actuator_method(cnt, con):
# forwards the data received on data in to data out with a delay
delay = self.registered_actuators[actuator_name]['delay']
gevent.sleep(delay)
if self.registered_actuators[actuator_name]['onoff'] == 'ON':
self.push_content(data_out_cnt, con)
add_actuator_method.__name__ = str(actuator_name + '_func')
setattr(self, add_actuator_method.__name__, add_actuator_method)
funcname = actuator_name + '_func'
actuatorfunc = getattr(self, funcname)
#self.add_container_subscription(data_in_cnt, actuatorfunc)
self.registered_actuators[actuator_name]['in_path'] = data_in_cnt.path
self.registered_actuators[actuator_name][
'out_path'] = data_out_cnt.path
self.registered_actuators[actuator_name]['name'] = actuator_name
# finally subscribe to the incoming data
self.add_container_subscription(data_in_cnt, actuatorfunc)
def main():
"""
Testing code
"""
def update_function(instance):
pass
e = ExpTimeUpdater(send_update=update_function, interval=5, offset=1)
from openmtc_onem2m.model import Container
from openmtc.util import datetime_now
from time import sleep
instance = Container(expirationTime=datetime_now(), path="/test/path")
e.start(instance)
sleep(10)
def test__on_register(self):
#self.fail()#
Container.maxNrOfInstances = 3
container1 = Container(resourceName='zigbee device1',
maxNrOfInstances=1)
#container2 = Container(resourceName1 = 'zigbee devices2',maxNrOfInstances = 1)
#container3 = Container(resourceName1 = 'zigbee devices3',maxNrOfInstances = 1)
#self.zigbee.devices_container1 = self.zigbee.create_container(None,container1)
# self.zigbee.devices_container2 = self.zigbee.create_container(None,container2)
# self.zigbee.devices_container3 = self.zigbee.create_container(None,container3)
#self.zigbee._on_register()
#self.assertEqual(1, self.zigbee.devices_container1)
#verify it is ok to have 0 instances
#self.zigbee._on_register()
#self.assertEqual(0, self.zigbee.devices_container1)
pass
def _create_sensor_structure(self, event):
device_container = self.create_container(
None,
Container(resourceName=event[self.device_classifier]),
labels=['openmtc:device'],
max_nr_of_instances=0)
self._recognized_sensors[event[
self.device_classifier]] = device_container
self._recognized_measurement_containers[event[
self.device_classifier]] = {}
for k in event.keys():
if k == "Date" or k == self.device_classifier or k in ("", None):
continue
self._create_measurement_container(event[self.device_classifier],
k)
def decode_request(self, resource, attr_to_write, value_to_write):
if isinstance(resource, CSEBase):
cse = CSEBase()
setattr(cse, attr_to_write, value_to_write)
return cse
elif isinstance(resource, AE):
ae = AE()
setattr(ae, attr_to_write, value_to_write)
return ae
elif isinstance(resource, Container):
cnt = Container()
setattr(cnt, attr_to_write, value_to_write)
return cnt
elif isinstance(resource, ContentInstance):
cin = ContentInstance()
setattr(cin, attr_to_write, value_to_write)
return cin
return resource
def _on_register(self):
# init variables
self._recognized_sensors = {}
self._recognized_measurement_containers = {}
# init base structure
label = 'devices'
container = Container(resourceName=label)
group = Group(resourceName="test")
self._devices_container = self.create_container(None,
container,
labels=[label],
max_nr_of_instances=0)
# trigger periodically new data generation
self.run_forever(1, self.get_random_data)
# log message
self.logger.debug('registered')
