def reg_device(self, dcc_pkg, edge_system_pkg, name, dev_type, prop_dict):
from liota.entities.devices.device import Device
from liota.lib.utilities.utility import systemUUID
# Acquire resources from registry
if not self.pkg_registry.has(dcc_pkg):
log.warning("%s package is not running" % dcc_pkg)
return None, None
dcc = self.pkg_registry.get(dcc_pkg)
dev = Device(name, systemUUID().get_uuid(name), dev_type)
# Register device
try:
with self.discovery_lock:
reg_dev = dcc.register(dev)
dcc.set_properties(reg_dev, prop_dict)
except:
return None, None
# TBM: temporarily assume devices will be attached to the only edge system
if self.pkg_registry.has(edge_system_pkg):
edge_system = self.pkg_registry.get(edge_system_pkg)
dcc.create_relationship(edge_system, reg_dev)
else:
log.warning("%s package is not loaded, please load it!" %
edge_system_pkg)
return dev, reg_dev
def reg_device_iotcc(self, name, dev_type, prop_dict):
from liota.entities.devices.device import Device
from liota.lib.utilities.utility import systemUUID
# Get values from configuration file
config_path = self._config['package_path']
config = {}
execfile(config_path + '/sampleProp.conf', config)
# Acquire resources from registry
if not self.pkg_registry.has("iotcc"):
log.warning("iotcc package is not running, please load it first!")
return None, None
iotcc = self.pkg_registry.get("iotcc")
dev = Device(name, systemUUID().get_uuid(name), dev_type)
prop_dict = self.add_organization_properties(iotcc, prop_dict)
# Register device
try:
with self.discovery_lock:
reg_dev = iotcc.register(dev)
iotcc.set_properties(reg_dev, prop_dict)
except:
return None, None
# TBM: temporarily assume devices will be attached to the only edge system
if self.pkg_registry.has("iotcc_edge_system"):
iotcc_edge_system = self.pkg_registry.get("iotcc_edge_system")
iotcc.create_relationship(iotcc_edge_system, reg_dev)
else:
log.warning("iotcc_edge_system package is not loaded, please load it!")
return dev, reg_dev
def reg_device_graphite(self, name, dev_type, prop_dict):
from liota.entities.devices.device import Device
from liota.lib.utilities.utility import systemUUID
# Get values from configuration file
config_path = self._config['package_path']
config = {}
execfile(config_path + '/sampleProp.conf', config)
# Acquire resources from registry
if not self.pkg_registry.has("graphite"):
log.warning("graphite package is not running, please load it first!")
return None, None
graphite = self.pkg_registry.get("graphite")
tmp = systemUUID().get_uuid(name)
dev = Device(name, tmp, dev_type)
# Register device
try:
with self.discovery_lock:
reg_dev = graphite.register(dev)
graphite.set_properties(reg_dev, prop_dict)
except:
return None, None
return dev, reg_dev
class PackageClass(LiotaPackage):
def run(self, registry):
"""
The execution function of a liota package.
Acquires "iotcc_mqtt" and "iotcc_mqtt_edge_system" from registry then register five devices
and publishes device metrics to the DCC
:param registry: the instance of ResourceRegistryPerPackage of the package
:return:
"""
from liota.entities.devices.device import Device
from liota.entities.metrics.metric import Metric
import copy
log.info("-----------beging register device with:" + device_name + "--" +device_metric_name)
# Acquire resources from registry
self.iotcc = registry.get("iotcc_mqtt")
# Creating a copy of edge_system object to keep original object "clean"
self.iotcc_edge_system = copy.copy(registry.get("iotcc_mqtt_edge_system"))
self.reg_devices = []
self.metrics = []
try:
# Register device
device = Device(device_name,systemUUID().get_uuid(device_name),"edgexfoundry")
log.info("Registration Started for Device".format(device.name))
# Device Registration
reg_device = self.iotcc.register(device)
self.reg_devices.append(reg_device)
self.iotcc.create_relationship(self.iotcc_edge_system, reg_device)
# Use the device name as identifier in the registry to easily refer the device in other packages
device_registry_name = device_name
registry.register(device_registry_name, reg_device)
log.info("----------------relation success:"+str(device_name)+"----------------------")
self.iotcc.set_properties(reg_device,
{"Country": "USA-G", "State": "California", "City": "Palo Alto",
"Location": "VMware HQ", "Building": "Promontory H Lab",
"Floor": "First Floor"})
try:
# Registering Metric for Device
metric_name = device_metric_name + "_metrics"
metric_simulated_received = Metric(name=metric_name, unit=None, interval=5,
aggregation_size=1, sampling_function=device_metric)
reg_metric_simulated_received = self.iotcc.register(metric_simulated_received)
self.iotcc.create_relationship(reg_device, reg_metric_simulated_received)
reg_metric_simulated_received.start_collecting()
log.info("--------------relation metics:"+device_metric_name+"----------------------")
self.metrics.append(reg_metric_simulated_received)
def __init__(self, name, device_mac, entity_type="Device"):
Device.__init__(self,
name=name,
entity_type=entity_type,
entity_id=systemUUID().get_uuid(name))
SensorTag.__init__(self, addr=device_mac)