def run(self, registry):
"""
The execution function of a liota package.
Establishes connection with AWSIoT DCC using MqttDccComms
:param registry: the instance of ResourceRegistryPerPackage of the package
:return:
"""
import copy
from liota.dccs.aws_iot import AWSIoT
from liota.dcc_comms.mqtt_dcc_comms import MqttDccComms
from liota.lib.transports.mqtt import QoSDetails
from liota.lib.utilities.identity import Identity
from liota.lib.utilities.tls_conf import TLSConf
# 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 = read_user_config(config_path + '/sampleProp.conf')
# Encapsulates Identity
identity = Identity(root_ca_cert=config['broker_root_ca_cert'], username=None, password=None,
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'])
# Encapsulate QoS related parameters
qos_details = QoSDetails(config['in_flight'], config['queue_size'], config['retry'])
# Connecting to AWSIoT
# Publish topic for all Metrics will be 'liota/generated_local_uuid_of_edge_system/request'
# Create and pass custom MqttMessagingAttributes object to MqttDccComms to have custom topic
self.aws_iot = AWSIoT(MqttDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'], port=config['BrokerPort'], identity=identity,
tls_conf=tls_conf,
qos_details=qos_details,
clean_session=True,
protocol=config['protocol'], transport=['transport'],
conn_disconn_timeout=config['ConnectDisconnectTimeout']),
enclose_metadata=True)
# Register edge system (gateway)
aws_iot_edge_system = self.aws_iot.register(edge_system)
registry.register("aws_iot", self.aws_iot)
registry.register("aws_iot_edge_system", aws_iot_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
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=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)
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_edge_system_mqtt", self.iotcc_edge_system)
except RegistrationFailure:
print "EdgeSystem registration to IOTCC failed"
self.iotcc.set_properties(self.iotcc_edge_system,
config['SystemPropList'])
def mqtt_subscribe():
# Encapsulates Identity
identity = Identity(config['broker_root_ca_cert'], config['broker_username'], config['broker_password'],
config['edge_system_cert_file'], config['edge_system_key_file'])
# Encapsulate TLS parameters
tls_conf = TLSConf(cert_required=config['cert_required'], tls_version=config['tls_version'],
cipher=config['cipher'])
# Create MQTT connection object with required params
mqtt_conn = MqttDeviceComms(url=config['BrokerIP'], port=config['BrokerPort'], identity=identity,
tls_conf=tls_conf,
qos_details=None,
clean_session=True,
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)
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'])
# d) Use combination of (a) and (c) or (b) and (c).
#
#
# AWSIoT DCC has enclose_metadata option. It can be used to enclose EdgeSystem, Device and Metric names
# along with the sensor data payload of a Metric.
#
# This example showcases publishing Metrics using (a) and enclose_metadata
# -----------------------------------------------------------------------------------------------------------------
if __name__ == '__main__':
# Creating EdgeSystem
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# Encapsulates Identity
identity = Identity(root_ca_cert=config['broker_root_ca_cert'],
username=None,
password=None,
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'])
# Encapsulate QoS related parameters
qos_details = QoSDetails(config['in_flight'], config['queue_size'],
config['retry'])
# Connecting to AWSIoT
# AWSIoT broker doesn't support session persistence. So, always use "clean_session=True"
# Publish topic for all Metrics will be 'liota/generated_local_uuid_of_edge_system/request'
aws = AWSIoT(MqttDccComms(
edge_system_name=edge_system.name,
url=config['BrokerIP'],
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.
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
# | |
# Temperature Humidity
# Metric Metric
#
#
# This example showcases publishing Metrics using Mode 3 (as described in README) and without enclose_metadata.
# It also shows how to consume messages from different AMQP exchanges
# ------------------------------------------------------------------------------------------------------------------
if __name__ == '__main__':
# Creating EdgeSystem
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# Encapsulates Identity
identity = Identity(config['broker_root_ca_cert'],
config['broker_username'],
config['broker_password'],
cert_file=None,
key_file=None)
# Encapsulate TLS parameters
tls_conf = TLSConf(config['cert_required'], config['tls_version'],
config['cipher'])
# Connecting to RabbitMQ
# Custom Publish Topic for an EdgeSystem
amqp_pub_msg_attr = AmqpPublishMessagingAttributes(
exchange_name=config['CommonExchangeName'],
routing_key=config['CommonRoutingKey'])
rabbitmq = RabbitMQ(
AmqpDccComms(edge_system_name=edge_system.name,
url=config['BrokerIP'],
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"
# ---------------------------------------------------------------------------
# In this example, we demonstrate how System health and some simulated data
# can be directed to data center components IoTCC using MQTT from 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 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
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
