def run(self, registry):
import copy
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.websocket_dcc_comms import WebSocketDccComms
from liota.dccs.dcc import RegistrationFailure
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Get values from configuration file
config_path = registry.get("package_conf")
config = {}
execfile(config_path + '/sampleProp.conf', config)
# Initialize DCC object with transport
self.iotcc = IotControlCenter(
config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl'])
)
try:
# Register edge system (gateway)
iotcc_edge_system = self.iotcc.register(edge_system)
"""
Use iotcc & iotcc_edge_system as common identifiers
in the registry to easily refer the objects in other packages
"""
registry.register("iotcc", self.iotcc)
registry.register("iotcc_edge_system", iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(iotcc_edge_system, config['SystemPropList'])
class PackageClass(LiotaPackage):
"""
This is a sample package which creates a IoTControlCenter DCC object and registers edge system on
IoTCC over MQTT Protocol to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.dccs.dcc import RegistrationFailure
from liota.lib.utilities.tls_conf import TLSConf
# Get values from configuration file
self.config_path = registry.get("package_conf")
config = read_user_config(self.config_path + '/sampleProp.conf')
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
identity = Identity(root_ca_cert=config['broker_root_ca_cert'], username=config['broker_username'],
password=config['broker_password'],
cert_file=config['edge_system_cert_file'], key_file=config['edge_system_key_file'])
# Encapsulate TLS parameters
tls_conf = TLSConf(config['cert_required'], config['tls_version'], config['cipher'])
# Initialize DCC object with MQTT transport
self.iotcc = IotControlCenter(MqttDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'], port=config['BrokerPort'], identity=identity,
tls_conf=tls_conf,
enable_authentication=True))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
"""
Use iotcc & iotcc_edge_system as common identifiers
in the registry to easily refer the objects in other packages
"""
registry.register("iotcc_mqtt", self.iotcc)
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(self.iotcc_edge_system, config['SystemPropList'])
def clean_up(self):
# Get values from configuration file
config = read_user_config(self.config_path + '/sampleProp.conf')
#Unregister edge system
if config['ShouldUnregisterOnUnload'] == "True":
self.iotcc.unregister(self.iotcc_edge_system)
self.iotcc.comms.client.disconnect()
class PackageClass(LiotaPackage):
"""
This is a sample package which creates a IoTControlCenter DCC object and registers edge system on
IoTCC over WebSocket to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.websocket_dcc_comms import WebSocketDccComms
from liota.dccs.dcc import RegistrationFailure
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Get values from configuration file
self.config_path = registry.get("package_conf")
config = read_user_config(self.config_path + '/sampleProp.conf')
identity = Identity(root_ca_cert=config['WebsocketCaCertFile'],
username=config['IotCCUID'],
password=config['IotCCPassword'],
cert_file=config['ClientCertFile'],
key_file=config['ClientKeyFile'])
# Initialize DCC object with transport
self.iotcc = IotControlCenter(
WebSocketDccComms(url=config['WebSocketUrl'],
verify_cert=config['VerifyServerCert'],
identity=identity))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
"""
Use iotcc & iotcc_edge_system as common identifiers
in the registry to easily refer the objects in other packages
"""
registry.register("iotcc", self.iotcc)
registry.register("iotcc_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(self.iotcc_edge_system,
config['SystemPropList'])
def clean_up(self):
# Get values from configuration file
config = read_user_config(self.config_path + '/sampleProp.conf')
# Unregister edge system
if config['ShouldUnregisterOnUnload'] == "True":
self.iotcc.unregister(self.iotcc_edge_system)
self.iotcc.comms.client.close()
class PackageClass(LiotaPackage):
"""
This is a sample package which creates a IoTControlCenter DCC object and registers edge system on
IoTCC over MQTT Protocol to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.dccs.dcc import RegistrationFailure
# Get values from configuration file
config_path = registry.get("package_conf")
config = {}
execfile(config_path + '/sampleProp.conf', config)
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
identity = Identity(root_ca_cert=None,
username=config['broker_username'],
password=config['broker_password'],
cert_file=None,
key_file=None)
# Initialize DCC object with MQTT transport
self.iotcc = IotControlCenter(
config['broker_username'], config['broker_password'],
MqttDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'],
port=config['BrokerPort'],
identity=identity,
enable_authentication=True,
clean_session=True))
try:
# Register edge system (gateway)
iotcc_edge_system = self.iotcc.register(edge_system)
"""
Use iotcc & iotcc_edge_system as common identifiers
in the registry to easily refer the objects in other packages
"""
registry.register("iotcc_mqtt", self.iotcc)
registry.register("iotcc_edge_system_mqtt", iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(iotcc_edge_system, config['SystemPropList'])
def clean_up(self):
self.iotcc.comms.client.disconnect()
def run(self, registry):
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.dccs.dcc import RegistrationFailure
from liota.lib.utilities.tls_conf import TLSConf
# Get values from configuration file
self.config_path = registry.get("package_conf")
config = {}
execfile(self.config_path + '/sampleProp.conf', config)
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
identity = Identity(root_ca_cert=config['broker_root_ca_cert'],
username=config['broker_username'],
password=config['broker_password'],
cert_file=config['edge_system_cert_file'],
key_file=config['edge_system_key_file'])
# Encapsulate TLS parameters
tls_conf = TLSConf(config['cert_required'], config['tls_version'],
config['cipher'])
# Initialize DCC object with MQTT transport
self.iotcc = IotControlCenter(
config['broker_username'], config['broker_password'],
MqttDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'],
port=config['BrokerPort'],
identity=identity,
tls_conf=tls_conf,
enable_authentication=True))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
"""
Use iotcc & iotcc_edge_system as common identifiers
in the registry to easily refer the objects in other packages
"""
registry.register("iotcc_mqtt", self.iotcc)
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(self.iotcc_edge_system,
config['SystemPropList'])
class PackageClass(LiotaPackage):
"""
This is a sample package which creates a IoTControlCenter DCC object and registers edge system on
IoTCC over WebSocket to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.websocket_dcc_comms import WebSocketDccComms
from liota.dccs.dcc import RegistrationFailure
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Get values from configuration file
self.config_path = registry.get("package_conf")
config = read_user_config(self.config_path + '/sampleProp.conf')
identity = Identity(root_ca_cert=config['WebsocketCaCertFile'], username=config['IotCCUID'],
password=config['IotCCPassword'],
cert_file=config['ClientCertFile'], key_file=config['ClientKeyFile'])
# Initialize DCC object with transport
self.iotcc = IotControlCenter(
WebSocketDccComms(url=config['WebSocketUrl'], verify_cert=config['VerifyServerCert'], identity=identity)
)
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
"""
Use iotcc & iotcc_edge_system as common identifiers
in the registry to easily refer the objects in other packages
"""
registry.register("iotcc", self.iotcc)
registry.register("iotcc_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(self.iotcc_edge_system, config['SystemPropList'])
def clean_up(self):
# Get values from configuration file
config = read_user_config(self.config_path + '/sampleProp.conf')
# Unregister edge system
if config['ShouldUnregisterOnUnload'] == "True":
self.iotcc.unregister(self.iotcc_edge_system)
self.iotcc.comms.client.close()
def run(self, registry):
import copy
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.websocket_dcc_comms import WebSocketDccComms
from liota.dccs.dcc import RegistrationFailure
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Get values from configuration file
config_path = registry.get("package_conf")
config = {}
execfile(config_path + '/sampleProp.conf', config)
# Initialize DCC object with transport
self.iotcc = IotControlCenter(
config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl'])
)
try:
# Register edge system (gateway)
iotcc_edge_system = self.iotcc.register(edge_system)
registry.register("iotcc", self.iotcc)
registry.register("iotcc_edge_system", iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(iotcc_edge_system, config['SystemPropList'])
def run(self, registry):
import copy
import time
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.lib.transports.mqtt import MqttMessagingAttributes
from liota.dccs.dcc import RegistrationFailure
from liota.lib.utilities.tls_conf import TLSConf
# Acquire resources from the registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
# Acquire credentials and required certificates from the registry
identity = Identity(root_ca_cert=registry.get("broker_root_ca_cert"), username=registry.get("broker_username"),
password=registry.get("broker_password"),
cert_file=registry.get("edge_system_cert_file"), key_file=registry.get("edge_system_key_file"))
# Encapsulate TLS parameters
tls_conf = TLSConf(cert_required="CERT_REQUIRED", tls_version="PROTOCOL_TLSv1_2", cipher=None)
# Initialize DCC object with MQTT transport
mqtt_msg_attr = MqttMessagingAttributes(pub_topic="liota/"+registry.get("broker_username")+"/request",sub_topic="liota/"+registry.get("broker_username")+"/response")
self.iotcc = IotControlCenter(MqttDccComms(edge_system_name=edge_system.name,
url=registry.get("broker_ip"), port=registry.get("broker_port"), identity=identity,
tls_conf=tls_conf,client_id=registry.get("broker_username"),
enable_authentication=True, mqtt_msg_attr=mqtt_msg_attr))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
# System Properties has to be set only for the registered edge system before it is stored in the package
# manager registry, all the devices will internally inherit the the system properties from the
# registered edge system
self.iotcc.set_system_properties(self.iotcc_edge_system, registry.get("system_properties"))
# Set the properties for edge system as key:value pair, you can also set the location
# by passing the latitude and longitude as a property in the user package
# If the set_properties or register call fails due to DCC_Comms Publish exception
# the optional retry mechanism can be implemented in the following way
attempts = 0
while attempts < 3:
try:
# Register edge system (gateway)
self.iotcc.set_properties(self.iotcc_edge_system, {"key1": "value1", "key2": "value2"})
break
except Exception:
attempts += 1
# The sleep time before re-trying depends on the infrastructure requirement of broker to restart
# It can be modified or removed as per the infrastructure requirement
time.sleep(5)
registry.register("iotcc_mqtt", self.iotcc)
# Store the registered edge system object in liota package manager registry after the
# system properties are set for it
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
def run(self, registry):
"""
The execution function of a liota package.
Establishes connection with IoTControlCenter DCC using MqttDccComms
:param registry: the instance of ResourceRegistryPerPackage of the package
:return:
"""
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.dccs.dcc import RegistrationFailure
from liota.lib.utilities.tls_conf import TLSConf
# Get values from configuration file
self.config_path = registry.get("package_conf")
config = read_user_config(self.config_path + '/sampleProp.conf')
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
identity = Identity(root_ca_cert=config['broker_root_ca_cert'], username=config['broker_username'],
password=config['broker_password'],
cert_file=config['edge_system_cert_file'], key_file=config['edge_system_key_file'])
# Encapsulate TLS parameters
tls_conf = TLSConf(config['cert_required'], config['tls_version'], config['cipher'])
# Initialize DCC object with MQTT transport
self.iotcc = IotControlCenter(MqttDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'], port=config['BrokerPort'], identity=identity,
tls_conf=tls_conf,
enable_authentication=True))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
"""
Use iotcc & iotcc_edge_system as common identifiers
in the registry to easily refer the objects in other packages
"""
registry.register("iotcc_mqtt", self.iotcc)
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(self.iotcc_edge_system, config['SystemPropList'])
class PackageClass(LiotaPackage):
"""
This package creates a IoTControlCenter DCC object and registers edge system on
IoTCC to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
import copy
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.websocket_dcc_comms import WebSocketDccComms
from liota.dccs.dcc import RegistrationFailure
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Get values from configuration file
config_path = registry.get("package_conf")
config = {}
execfile(config_path + '/sampleProp.conf', config)
# Initialize DCC object with transport
self.iotcc = IotControlCenter(
config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl']))
try:
# Register edge system (gateway)
iotcc_edge_system = self.iotcc.register(edge_system)
registry.register("iotcc", self.iotcc)
registry.register("iotcc_edge_system", iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(iotcc_edge_system, config['SystemPropList'])
def clean_up(self):
self.iotcc.comms.wss.close()
class PackageClass(LiotaPackage):
"""
This package creates a IoTControlCenter DCC object and registers edge system on
IoTCC to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
import copy
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.websocket_dcc_comms import WebSocketDccComms
from liota.dccs.dcc import RegistrationFailure
# Acquire resources from registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Get values from configuration file
config_path = registry.get("package_conf")
config = {}
execfile(config_path + '/sampleProp.conf', config)
# Initialize DCC object with transport
self.iotcc = IotControlCenter(
config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl'])
)
try:
# Register edge system (gateway)
iotcc_edge_system = self.iotcc.register(edge_system)
registry.register("iotcc", self.iotcc)
registry.register("iotcc_edge_system", iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
def clean_up(self):
self.iotcc.comms.wss.close()
# Creating EdgeSystem
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# Encapsulates Identity
identity = Identity(root_ca_cert=config['broker_root_ca_cert'],
username=config['broker_username'],
password=config['broker_password'],
cert_file=config['edge_system_cert_file'],
key_file=config['edge_system_key_file'])
# Encapsulate TLS parameters
tls_conf = TLSConf(config['cert_required'], config['tls_version'],
config['cipher'])
iotcc = IotControlCenter(
MqttDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'],
port=config['BrokerPort'],
identity=identity,
tls_conf=tls_conf,
enable_authentication=True))
try:
# resister the IoT System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
# ---------- Create metrics 'on' the Resource in IoTCC representing the IoT System
# Creating EdgeSystem
edge_system = Dk300EdgeSystem(config['EdgeSystemName'])
# Connect with MQTT broker using DeviceComms and subscribe to topics
# Get kitchen and living room temperature values using MQTT channel
mqtt_subscribe()
# Create DCC object IoTCC using websocket transport
# with UID and PASS
ws_identity = Identity(root_ca_cert=config['WebsocketCaCertFile'], username=config['IotCCUID'],
password=config['IotCCPassword'],
cert_file=config['ClientCertFile'], key_file=config['ClientKeyFile'])
# Initialize DCC object with transport
iotcc = IotControlCenter(
WebSocketDccComms(url=config['WebSocketUrl'], verify_cert=config['VerifyServerCert'], identity=ws_identity)
)
try:
# Register Edge System with IoT control center
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
# Create kitchen device object and register it on IoTCC
# Add two device names in the configurations as DeviceName1 and DeviceName2
kitchen_temperature_device = SimulatedDevice(name=config['DeviceName1'])
reg_kitchen_temperature_device = iotcc.register(kitchen_temperature_device)
def run(self, registry):
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.lib.transports.mqtt import MqttMessagingAttributes
from liota.dccs.dcc import RegistrationFailure
from liota.lib.utilities.tls_conf import TLSConf
# Acquire resources from the registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
# Acquire credentials and required certificates from the registry
identity = Identity(root_ca_cert=registry.get("broker_root_ca_cert"),
username=registry.get("broker_username"),
password=registry.get("broker_password"),
cert_file=registry.get("edge_system_cert_file"),
key_file=registry.get("edge_system_key_file"))
# Encapsulate TLS parameters
tls_conf = TLSConf(cert_required="CERT_REQUIRED",
tls_version="PROTOCOL_TLSv1_2",
cipher=None)
# Initialize DCC object with MQTT transport
mqtt_msg_attr = MqttMessagingAttributes(
pub_topic="liota/" + registry.get("broker_username") + "/request",
sub_topic="liota/" + registry.get("broker_username") + "/response")
self.iotcc = IotControlCenter(
MqttDccComms(edge_system_name=edge_system.name,
url=registry.get("broker_ip"),
port=registry.get("broker_port"),
identity=identity,
tls_conf=tls_conf,
client_id=registry.get("broker_username"),
enable_authentication=True,
mqtt_msg_attr=mqtt_msg_attr))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
# System Properties has to be set only for the registered edge system before it is stored in the package
# manager registry, all the devices will internally inherit the the system properties from the
# registered edge system
self.iotcc.set_system_properties(self.iotcc_edge_system,
registry.get("system_properties"))
# Set the properties for edge system as key:value pair, you can also set the location
# by passing the latitude and longitude as a property in the user package
self.iotcc.set_properties(self.iotcc_edge_system, {
"key1": "value1",
"key2": "value2"
})
registry.register("iotcc_mqtt", self.iotcc)
# Store the registered edge system object in liota package manager registry after the
# system properties are set for it
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
clean_session=True,
port=config['BrokerPort'],
keep_alive=config['keep_alive'],
enable_authentication=True)
# Subscribe to channels : "temperature/kitchen" and "temperature/living-room" with preferred QoS level 0, 1 or 2
# Provide callback function as a parameter for corresponding channel
mqtt_conn.subscribe(config['MqttChannel1'], 1, callback_kitchen_temp)
mqtt_conn.subscribe(config['MqttChannel2'], 1, callback_living_room_temp)
if __name__ == "__main__":
# Create DCC object IoTCC using websocket transport
# with UID and PASS
iotcc = IotControlCenter(config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl']))
try:
# Create an Edge System Dk300
edge_system = Dk300EdgeSystem(config['EdgeSystemName'])
# Get kitchen and living room temperature values using MQTT channel
mqtt_subscribe(edge_system)
# Register Edge System with IoT control center
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
if __name__ == '__main__':
# create a data center object, IoTCC in this case, using MQTT as a transport layer
# this object encapsulates the formats and protocols necessary for the agent to interact with the dcc
# UID/PASS login for now.
# Creating EdgeSystem
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# Encapsulates Identity
identity = Identity(root_ca_cert=config['broker_root_ca_cert'], username=config['broker_username'], password=config['broker_password'],
cert_file=config['edge_system_cert_file'], key_file=config['edge_system_key_file'])
# Encapsulate TLS parameters
tls_conf = TLSConf(config['cert_required'], config['tls_version'], config['cipher'])
iotcc = IotControlCenter(MqttDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'], port=config['BrokerPort'], identity=identity,
tls_conf=tls_conf,
enable_authentication=True))
try:
# resister the IoT System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
# ---------- Create metrics 'on' the Resource in IoTCC representing the IoT System
# arguments:
# local object referring to the Resource in IoTCC on which the metric should be associated
mem_free_percent = ((total_mem-free_mem)/total_mem)*100
return round(mem_free_percent, 2)
#---------------------------------------------------------------------------
# In this example, we demonstrate how System health and some simulated data
# can be directed to data center component IoTCC using Liota.
# The program illustrates the ease of use Liota brings to IoT application developers.
if __name__ == '__main__':
# create a data center object, IoTCC in this case, using websocket as a transport layer
# this object encapsulates the formats and protocols necessary for the agent to interact with the dcc
# UID/PASS login for now.
iotcc = IotControlCenter(config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl']))
try:
# create a System object encapsulating the particulars of a IoT System
# argument is the name of this IoT System
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# resister the IoT System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
# ---------- Create metrics 'on' the Resource in IoTCC representing the IoT System
return rpm_model_queue.get(block=True)
def action_actuator(value):
print value
# ---------------------------------------------------------------------------------------
# In this example, we demonstrate how metrics collected from a SensorTag device over BLE
# can be directed to IoTCC data center component using Liota.
# The program illustrates the ease of use Liota brings to IoT application developers.
if __name__ == '__main__':
# create a data center object, IoTCC in this case, using websocket as a transport layer
iotcc = IotControlCenter(config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl']))
try:
# create a System object encapsulating the particulars of a IoT System
# argument is the name of this IoT System
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# resister the IoT System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
# Operational metrics of EdgeSystem
class PackageClass(LiotaPackage):
"""
This is a sample package which creates a IoTControlCenter DCC object and registers edge system on
IoTCC over MQTT Protocol to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
import copy
import time
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.lib.transports.mqtt import MqttMessagingAttributes
from liota.dccs.dcc import RegistrationFailure
from liota.lib.utilities.tls_conf import TLSConf
# Acquire resources from the registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
# Acquire credentials and required certificates from the registry
identity = Identity(root_ca_cert=registry.get("broker_root_ca_cert"),
username=registry.get("broker_username"),
password=registry.get("broker_password"),
cert_file=registry.get("edge_system_cert_file"),
key_file=registry.get("edge_system_key_file"))
# Encapsulate TLS parameters
tls_conf = TLSConf(cert_required="CERT_REQUIRED",
tls_version="PROTOCOL_TLSv1_2",
cipher=None)
# Initialize DCC object with MQTT transport
mqtt_msg_attr = MqttMessagingAttributes(
pub_topic="liota/" + registry.get("broker_username") + "/request",
sub_topic="liota/" + registry.get("broker_username") + "/response")
self.iotcc = IotControlCenter(
MqttDccComms(edge_system_name=edge_system.name,
url=registry.get("broker_ip"),
port=registry.get("broker_port"),
identity=identity,
tls_conf=tls_conf,
client_id=registry.get("broker_username"),
enable_authentication=True,
mqtt_msg_attr=mqtt_msg_attr))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
# System Properties has to be set only for the registered edge system before it is stored in the package
# manager registry, all the devices will internally inherit the the system properties from the
# registered edge system
self.iotcc.set_system_properties(self.iotcc_edge_system,
registry.get("system_properties"))
# Set the properties for edge system as key:value pair, you can also set the location
# by passing the latitude and longitude as a property in the user package
# If the set_properties or register call fails due to DCC_Comms Publish exception
# the optional retry mechanism can be implemented in the following way
attempts = 0
while attempts < 3:
try:
# Register edge system (gateway)
self.iotcc.set_properties(self.iotcc_edge_system, {
"key1": "value1",
"key2": "value2"
})
break
except Exception:
attempts += 1
# The sleep time before re-trying depends on the infrastructure requirement of broker to restart
# It can be modified or removed as per the infrastructure requirement
time.sleep(5)
registry.register("iotcc_mqtt", self.iotcc)
# Store the registered edge system object in liota package manager registry after the
# system properties are set for it
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
def clean_up(self):
# Unregister the edge system on package unload
# Kindly include the edge system un-register call on package unload
self.iotcc.unregister(self.iotcc_edge_system)
self.iotcc.comms.client.disconnect()
thermistor_model.get_c3(),
get_rx(thermistor_model.get_u(), thermistor_model.get_r0(),
thermistor_model.get_ux())).to(ureg.degC)
return temper.magnitude
# ---------------------------------------------------------------------------
# In this example, we demonstrate how simulated data can be directed to IoTCC
# VMware's data center component using Liota.
if __name__ == '__main__':
# create a data center object, IotCC in this case, using websocket as a transport layer
# this object encapsulates the formats and protocols neccessary for the agent to interact with the dcc
# UID/PASS login for now.
iotcc = IotControlCenter(config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl']))
try:
# create a Edge System object encapsulating the particulars of a gateway/board
# argument is the name of this Edge System
edge_system = Dk300EdgeSystem(config['EdgeSystemName'])
# resister the Edge System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
10 * ureg.kg / ureg.m**3).to(ureg.newton),
speed).to(ureg.watt)
power = power_acceleration + power_gravity + power_resistance
return power.to(ureg.watt).magnitude
# ---------------------------------------------------------------------------
# In this example, we demonstrate how simulated data can be directed to IoTCC
# VMware's data center component using Liota.
if __name__ == '__main__':
# create a data center object, IotCC in this case, using websocket as a transport layer
# this object encapsulates the formats and protocols neccessary for the agent to interact with the dcc
# UID/PASS login for now.
iotcc = IotControlCenter(config['IotCCUID'], config['IotCCPassword'],
WebSocketDccComms(url=config['WebSocketUrl']))
try:
# create a Edge System object encapsulating the particulars of a gateway/board
# argument is the name of this Edge System
edge_system = Dk300EdgeSystem(config['EdgeSystemName'])
# resister the Edge System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
# ---------------------------------------------------------------------------
# In this example, we demonstrate how simulated data can be directed to IoTCC
# VMware's data center component using Liota.
if __name__ == '__main__':
# create a data center object, IotCC in this case, using websocket as a transport layer
# this object encapsulates the formats and protocols neccessary for the agent to interact with the dcc
# UID/PASS login for now.
identity = Identity(root_ca_cert=config['WebsocketCaCertFile'], username=config['IotCCUID'],
password=config['IotCCPassword'],
cert_file=config['ClientCertFile'], key_file=config['ClientKeyFile'])
# Initialize DCC object with transport
iotcc = IotControlCenter(
WebSocketDccComms(url=config['WebSocketUrl'], verify_cert=config['VerifyServerCert'], identity=identity)
)
try:
# create a Edge System object encapsulating the particulars of a gateway/board
# argument is the name of this Edge System
edge_system = Dk300EdgeSystem(config['EdgeSystemName'])
# resister the Edge System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
# ---------------------------------------------------------------------------
# In this example, we demonstrate how simulated data can be directed to IoTCC
# VMware's data center component using Liota.
if __name__ == '__main__':
# create a data center object, IotCC in this case, using websocket as a transport layer
# this object encapsulates the formats and protocols neccessary for the agent to interact with the dcc
# UID/PASS login for now.
identity = Identity(root_ca_cert=config['WebsocketCaCertFile'], username=config['IotCCUID'],
password=config['IotCCPassword'],
cert_file=config['ClientCertFile'], key_file=config['ClientKeyFile'])
# Initialize DCC object with transport
iotcc = IotControlCenter(
WebSocketDccComms(url=config['WebSocketUrl'], verify_cert=config['VerifyServerCert'], identity=identity)
)
try:
# create a Edge System object encapsulating the particulars of a gateway/board
# argument is the name of this Edge System
edge_system = Dk300EdgeSystem(config['EdgeSystemName'])
# resister the Edge System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
def run(self, registry):
"""
The execution function of a liota package.
Establishes connection with IoTControlCenter DCC using MqttDccComms
:param registry: the instance of ResourceRegistryPerPackage of the package
:return:
"""
import copy
import time
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.lib.transports.mqtt import MqttMessagingAttributes
from liota.dccs.dcc import RegistrationFailure
from liota.lib.utilities.tls_conf import TLSConf
# Acquire resources from the registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
# Acquire credentials and required certificates from the registry
identity = Identity(root_ca_cert=registry.get("broker_root_ca_cert"), username=registry.get("broker_username"),
password=registry.get("broker_password"),
cert_file=registry.get("edge_system_cert_file"),
key_file=registry.get("edge_system_key_file"))
# Encapsulate TLS parameters
tls_conf = TLSConf(cert_required="CERT_REQUIRED", tls_version="PROTOCOL_TLSv1_2", cipher=None)
# Initialize DCC object with MQTT transport
mqtt_msg_attr = MqttMessagingAttributes(pub_topic="liota/" + registry.get("broker_username") + "/request",
sub_topic="liota/" + registry.get("broker_username") + "/response")
self.iotcc = IotControlCenter(MqttDccComms(edge_system_name=edge_system.name,
url=registry.get("broker_ip"), port=registry.get("broker_port"),
identity=identity,
tls_conf=tls_conf, client_id=registry.get("broker_username"),
enable_authentication=True, mqtt_msg_attr=mqtt_msg_attr))
try:
# Register edge system (gateway)
self.iotcc_edge_system = self.iotcc.register(edge_system)
# Set the properties for edge system as key:value pair, you can also set the location
# by passing the latitude and longitude as a property in the user package
# If the set_properties or register call fails due to DCC_Comms Publish exception
# the optional retry mechanism can be implemented in the following way
attempts = 0
max_retry_attempts = 3
while attempts < max_retry_attempts:
try:
# Register edge system (gateway)
self.iotcc.set_properties(self.iotcc_edge_system, {"key1": "value1", "key2": "value2"})
break
except Exception:
# In the third attempt if get exception raise it
if attempts == max_retry_attempts:
raise
attempts += 1
# The sleep time before re-trying depends on the infrastructure requirement of broker to restart
# It can be modified or removed as per the infrastructure requirement
time.sleep(5)
registry.register("iotcc_mqtt", self.iotcc)
# Store the registered edge system object in liota package manager registry after the
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
def run(self, registry):
"""
The execution function of a liota package.
Establishes connection with IoTControlCenter DCC using MqttDccComms
:param registry: the instance of ResourceRegistryPerPackage of the package
:return:
"""
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.lib.transports.mqtt import MqttMessagingAttributes
from liota.lib.utilities.tls_conf import TLSConf
# Acquire resources from the registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
# Acquire credentials and required certificates from the registry
identity = Identity(root_ca_cert=registry.get("broker_root_ca_cert"), username=registry.get("broker_username"),
password=registry.get("broker_password"),
cert_file=registry.get("edge_system_cert_file"),
key_file=registry.get("edge_system_key_file"))
# Encapsulate TLS parameters
tls_conf = TLSConf(cert_required="CERT_REQUIRED", tls_version="PROTOCOL_TLSv1_2", cipher=None)
# Initialize DCC object with MQTT transport
mqtt_msg_attr = MqttMessagingAttributes(pub_topic="liota/" + registry.get("broker_username") + "/request",
sub_topic="liota/" + registry.get("broker_username") + "/response")
# Attempts for establishing MQTT Connection
conn_attempts = 0
try:
# Trying to establish MQTT Connection with retry attempts in case of exception
while conn_attempts <= retry_attempts:
try:
self.iotcc = IotControlCenter(
MqttDccComms(edge_system_name=edge_system.name, url=registry.get("broker_ip"),
port=registry.get("broker_port"), identity=identity, tls_conf=tls_conf,
client_id=registry.get("broker_username"), enable_authentication=True,
mqtt_msg_attr=mqtt_msg_attr))
break
except Exception as e:
if conn_attempts == retry_attempts:
raise
conn_attempts += 1
log.error('MQTT Connection failed - {0}'.format(str(e)))
log.info('Trying MQTT Connection: Attempt - {0}'.format(str(conn_attempts)))
time.sleep(mqtt_connection_delay_retries)
# Attempts for Edge System Registration
reg_attempts = 0
# Edge System Registration with retry attempts in case of exception
while reg_attempts <= retry_attempts:
try:
self.iotcc_edge_system = self.iotcc.register(edge_system)
break
except Exception as e:
if reg_attempts == retry_attempts:
raise
reg_attempts += 1
log.error('Exception while registering Edge System- {0}'.format(str(e)))
log.info('Trying Edge System {0} Registration: Attempt - {1}'.format(edge_system.name,
str(reg_attempts)))
time.sleep(delay_retries)
registry.register("iotcc_mqtt", self.iotcc)
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
# Attempts for setting edge system properties
prop_attempts = 0
# Set multiple properties by passing Dictonary object for Edge System with the retry attempts
# in case of exceptions
while prop_attempts < retry_attempts:
try:
self.iotcc.set_properties(self.iotcc_edge_system,
{"Country": "USA-G", "State": "California", "City": "Palo Alto",
"Location": "VMware HQ", "Building": "Promontory H Lab",
"Floor": "First Floor"})
break
except Exception as e:
prop_attempts += 1
log.error(
'Exception while setting Property for Edge System {0} - {1}'.format(edge_system.name, str(e)))
log.info('Trying setting properties for Edge System {0}: Attempt - {1}'.format(edge_system.name,
str(prop_attempts)))
time.sleep(delay_retries)
except Exception:
log.error("EdgeSystem registration to IOTCC failed even after all the retries, starting connection cleanup")
# Disconnecting MQTT
self.iotcc.comms.client.disconnect()
raise
# The program illustrates the ease of use Liota brings to IoT application developers.
if __name__ == '__main__':
# create a data center object, IoTCC in this case, using websocket as a transport layer
# this object encapsulates the formats and protocols necessary for the agent to interact with the dcc
# UID/PASS login for now.
identity = Identity(root_ca_cert=config['WebsocketCaCertFile'],
username=config['IotCCUID'],
password=config['IotCCPassword'],
cert_file=config['ClientCertFile'],
key_file=config['ClientKeyFile'])
# Initialize DCC object with transport
iotcc = IotControlCenter(
WebSocketDccComms(url=config['WebSocketUrl'],
verify_cert=config['VerifyServerCert'],
identity=identity))
try:
# create a System object encapsulating the particulars of a IoT System
# argument is the name of this IoT System
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# resister the IoT System with the IoTCC instance
# this call creates a representation (a Resource) in IoTCC for this IoT System with the name given
reg_edge_system = iotcc.register(edge_system)
# these call set properties on the Resource representing the IoT System
# properties are a key:value store
reg_edge_system.set_properties(config['SystemPropList'])
class PackageClass(LiotaPackage):
"""
This is a sample package which creates a IoTControlCenter DCC object and registers edge system on
IoTCC over MQTT Protocol to acquire "registered edge system", i.e. iotcc_edge_system.
"""
def run(self, registry):
"""
The execution function of a liota package.
Establishes connection with IoTControlCenter DCC using MqttDccComms
:param registry: the instance of ResourceRegistryPerPackage of the package
:return:
"""
import copy
from liota.lib.utilities.identity import Identity
from liota.dccs.iotcc import IotControlCenter
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.lib.transports.mqtt import MqttMessagingAttributes
from liota.lib.utilities.tls_conf import TLSConf
# Acquire resources from the registry
# Creating a copy of edge_system object to keep original object "clean"
edge_system = copy.copy(registry.get("edge_system"))
# Encapsulates Identity
# Acquire credentials and required certificates from the registry
identity = Identity(root_ca_cert=registry.get("broker_root_ca_cert"),
username=registry.get("broker_username"),
password=registry.get("broker_password"),
cert_file=registry.get("edge_system_cert_file"),
key_file=registry.get("edge_system_key_file"))
# Encapsulate TLS parameters
tls_conf = TLSConf(cert_required="CERT_REQUIRED",
tls_version="PROTOCOL_TLSv1_2",
cipher=None)
# Initialize DCC object with MQTT transport
mqtt_msg_attr = MqttMessagingAttributes(
pub_topic="liota/" + registry.get("broker_username") + "/request",
sub_topic="liota/" + registry.get("broker_username") + "/response")
# Attempts for establishing MQTT Connection
conn_attempts = 0
try:
# Trying to establish MQTT Connection with retry attempts in case of exception
while conn_attempts <= retry_attempts:
try:
self.iotcc = IotControlCenter(
MqttDccComms(edge_system_name=edge_system.name,
url=registry.get("broker_ip"),
port=registry.get("broker_port"),
identity=identity,
tls_conf=tls_conf,
client_id=registry.get("broker_username"),
enable_authentication=True,
mqtt_msg_attr=mqtt_msg_attr))
break
except Exception as e:
if conn_attempts == retry_attempts:
raise
conn_attempts += 1
log.error('MQTT Connection failed - {0}'.format(str(e)))
log.info('Trying MQTT Connection: Attempt - {0}'.format(
str(conn_attempts)))
time.sleep(mqtt_connection_delay_retries)
# Attempts for Edge System Registration
reg_attempts = 0
# Edge System Registration with retry attempts in case of exception
while reg_attempts <= retry_attempts:
try:
self.iotcc_edge_system = self.iotcc.register(edge_system)
break
except Exception as e:
if reg_attempts == retry_attempts:
raise
reg_attempts += 1
log.error(
'Exception while registering Edge System- {0}'.format(
str(e)))
log.info(
'Trying Edge System {0} Registration: Attempt - {1}'.
format(edge_system.name, str(reg_attempts)))
time.sleep(delay_retries)
registry.register("iotcc_mqtt", self.iotcc)
registry.register("iotcc_mqtt_edge_system", self.iotcc_edge_system)
# Attempts for setting edge system properties
prop_attempts = 0
# Set multiple properties by passing Dictonary object for Edge System with the retry attempts
# in case of exceptions
while prop_attempts < retry_attempts:
try:
self.iotcc.set_properties(self.iotcc_edge_system,
config['SystemPropList'])
break
except Exception as e:
prop_attempts += 1
log.error(
'Exception while setting Property for Edge System {0} - {1}'
.format(edge_system.name, str(e)))
log.info(
'Trying setting properties for Edge System {0}: Attempt - {1}'
.format(edge_system.name, str(prop_attempts)))
time.sleep(delay_retries)
except Exception:
log.error(
"EdgeSystem registration to IOTCC failed even after all the retries, starting connection cleanup"
)
# Disconnecting MQTT
self.iotcc.comms.client.disconnect()
raise
def clean_up(self):
# Unregister the edge system
# On the unload of the package the Edge System will get unregistered and the entire history will be deleted
# from Pulse IoT Control Center so comment the below logic if the unregsitration of the device is not required
# to be done on the package unload
self.iotcc.unregister(self.iotcc_edge_system)
# Disconnecting MQTT
self.iotcc.comms.client.disconnect()
log.info("Cleanup completed successfully")