def test_graphite_dcc_init_fail_without_DCCComms(self):
with self.assertRaises(Exception):
g = Graphite("asd")
assert not isinstance(g, Graphite)
with self.assertRaises(Exception):
# noinspection PyArgumentList
g = Graphite()
assert g is None
def run(self, registry):
import copy
from liota.dccs.graphite import Graphite
from liota.dcc_comms.socket_comms import SocketDccComms
from liota.lib.utilities.offline_buffering import BufferingParams
# Acquire resources from registry
# Creating a copy of 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')
# Initialize DCC object with transport
offline_buffering = BufferingParams(persistent_storage=True,
queue_size=-1,
data_drain_size=10,
draining_frequency=1)
self.graphite = Graphite(SocketDccComms(ip=config['GraphiteIP'],
port=config['GraphitePort']),
buffering_params=offline_buffering)
# Register gateway system
graphite_edge_system = self.graphite.register(edge_system)
registry.register("graphite", self.graphite)
registry.register("graphite_edge_system", graphite_edge_system)
def run(self, registry):
import copy
from liota.dccs.graphite import Graphite
from liota.dcc_comms.socket_comms import SocketDccComms
# Acquire resources from registry
# Creating a copy of 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')
# Initialize DCC object with transport
self.graphite = Graphite(
SocketDccComms(ip=config['GraphiteIP'],
port=config['GraphitePort']))
# Register gateway system
graphite_edge_system = self.graphite.register(edge_system)
registry.register("graphite", self.graphite)
registry.register("graphite_edge_system", graphite_edge_system)
#---------------------------------------------------------------------------
# In this example, we demonstrate how data from a simulated device generating
# random physical variables can be directed to graphite data center component
# using Liota.
if __name__ == '__main__':
edge_system = Dell5KEdgeSystem(config['EdgeSystemName'])
# initialize and run the physical model (simulated device)
bike_model = BikeSimulated(name=config['DeviceName'], ureg=ureg)
# Sending data to Graphite data center component
# Socket is the underlying transport used to connect to the Graphite
# instance
graphite = Graphite(
SocketDccComms(ip=config['GraphiteIP'], port=config['GraphitePort']))
graphite_reg_dev = graphite.register(bike_model)
metric_name = "model.bike.speed"
bike_speed = Metric(name=metric_name,
unit=(ureg.m / ureg.sec),
interval=5,
sampling_function=get_bike_speed)
reg_bike_speed = graphite.register(bike_speed)
graphite.create_relationship(graphite_reg_dev, reg_bike_speed)
reg_bike_speed.start_collecting()
metric_name = "model.bike.power"
bike_power = Metric(name=metric_name,
unit=ureg.watt,
interval=5,
return temp_kelvin.magnitude
# --------------------------------------------------------------------------
# In this example, we demonstrate how data from a simulated device generating
# random numbers can be directed to graphite data center component using Liota.
# The program illustrates the ease of use Liota brings to IoT application developers.
if __name__ == '__main__':
edge_system = Dk300EdgeSystem(config['EdgeSystemName'])
# Sending data to Graphite data center component
# Socket is the underlying transport used to connect to the Graphite
# instance
graphite = Graphite(
Socket(ip=config['GraphiteIP'], port=config['GraphitePort']))
graphite_reg_edge_system = graphite.register(edge_system)
metric_name_temp_degC = config['MetricNameTempDegC']
temp_metric_degC = Metric(name=metric_name_temp_degC,
unit=ureg.degC,
interval=33,
aggregation_size=6,
sampling_function=getTempDegC)
reg_temp_metric_degC = graphite.register(temp_metric_degC)
graphite.create_relationship(graphite_reg_edge_system,
reg_temp_metric_degC)
reg_temp_metric_degC.start_collecting()
metric_name_temp_degF = config['MetricNameTempDegF']
temp_metric_degF = Metric(name=metric_name_temp_degF,
return random.randint(10, 25)
def get_vibration():
return round(random.uniform(0.480, 0.7), 3)
# ---------------------------------------------------------------------------------------
# In this example, we demonstrate how metrics collected from a SensorTag device over BLE
# can be directed to graphite 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, graphite in this case, using websocket as a transport layer
graphite = Graphite(SocketDccComms(ip=config['GraphiteIP'], port=8080))
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 graphite instance
# this call creates a representation (a Resource) in graphite for this IoT System with the name given
reg_edge_system = graphite.register(edge_system)
tf_rpm_metric = Metric(name="windmill.RPM",
unit=None,
interval=1,
aggregation_size=1,
sampling_function=get_rpm)
rule_rpm_metric = Metric(name="rpm",
unit=None,
interval=1,
aggregation_size=1,
sampling_function=get_rpm)
rpm_limit = 45
vib_limit = 0.500
ModelRule = lambda rpm, vib: 1 if (rpm >= rpm_limit and vib >=
vib_limit) else 0
exceed_limit = 1 #number of consecutive times a limit can be exceeded
edge_component = RuleEdgeComponent(ModelRule,
exceed_limit,
actuator_udm=action_actuator)
graphite = Graphite(SocketDccComms(ip=config['GraphiteIP'], port=8080),
edge_component)
reg_edge_system = graphite.register(edge_system)
rule_reg_rpm_metric = graphite.register(rule_rpm_metric)
rule_reg_rpm_metric.start_collecting()
rule_vib_metric = Metric(name="vib",
unit=None,
interval=2,
aggregation_size=1,
sampling_function=get_vibration)
rule_reg_vib_metric = graphite.register(rule_vib_metric)
rule_reg_vib_metric.start_collecting()
except RegistrationFailure:
# random numbers can be directed to graphite data center component using Liota.
# The program illustrates the ease of use Liota brings to IoT application
# developers.
def xmpp_subscribe():
xmpp_conn = XmppDeviceComms("[email protected]", "m1ndst1x", "127.0.0.1",
"5222")
xmpp_conn.subscribe("pubsub.127.0.0.1", "/vmware11",
callback_openfire_data)
if __name__ == '__main__':
xmpp_subscribe()
edge_system = SimulatedEdgeSystem('EdgeSystemName')
# Sending data to Graphite data center component
# Socket is the underlying transport used to connect to the Graphite
# instance
graphite = Graphite(SocketDccComms(ip='127.0.0.1', port=80))
graphite_reg_edge_system = graphite.register(edge_system)
metric_name = 'OpenfireData'
openfire_metric = Metric(
name=metric_name,
interval=0,
sampling_function=lambda: get_value(openfire_data))
reg_openfire_metric = graphite.register(openfire_metric)
graphite.create_relationship(graphite_reg_edge_system, reg_openfire_metric)
reg_openfire_metric.start_collecting()
def test_graphite_dcc_init_takes_DCCComms(self):
mock_dccc = mock.create_autospec(DCCComms)
g = Graphite(mock_dccc)
assert isinstance(g, Graphite)
