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')