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'])
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'])
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'])
# 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'])
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
# 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
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"
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=None, username=config['broker_username'], password=config['broker_password'],
cert_file=None, key_file=None)
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:
# 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:
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