Lightning-rod is the IoT node-side agent for the IoTronic service.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
iotronic-lightning-rod/iotronic_lightningrod/lightningrod.py

1137 lines
35 KiB

# Copyright 2017 MDSLAB - University of Messina All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
__author__ = "Nicola Peditto <n.peditto@gmail.com>"
# Autobahn imports
from autobahn.asyncio.component import Component
from autobahn.wamp import exception
# OSLO imports
from oslo_config import cfg
from oslo_log import log as logging
# MODULES imports
import asyncio
import inspect
import os
import pkg_resources
import signal
import ssl
import sys
import time
import txaio
from pip._vendor import pkg_resources
from stevedore import extension
# IoTronic imports
from iotronic_lightningrod.Board import Board
from iotronic_lightningrod.common.exception import timeoutALIVE
from iotronic_lightningrod.common.exception import timeoutRPC
from iotronic_lightningrod.common import utils
from iotronic_lightningrod.modules import utils as lr_utils
import iotronic_lightningrod.wampmessage as WM
# Global variables
LOG = logging.getLogger(__name__)
CONF = cfg.CONF
# LR options
lr_opts = [
cfg.StrOpt('lightningrod_home',
default='/var/lib/iotronic',
help=('Lightning-rod Home Data')
),
cfg.BoolOpt('skip_cert_verify',
default=True,
help=('Flag for skipping the verification of the server cert '
'(for the auto-signed ones)')
),
cfg.StrOpt('log_level',
default='info',
help=('Lightning-rod log level')
),
]
CONF.register_opts(lr_opts)
# Autobahn options
autobahn_opts = [
cfg.IntOpt('connection_timer',
default=10,
help=('IoTronic connection RPC timer')),
cfg.IntOpt('alive_timer',
default=600,
help=('Wamp websocket check time')),
cfg.IntOpt('rpc_alive_timer',
default=3,
help=('RPC alive response time threshold')),
cfg.IntOpt('connection_failure_timer',
default=600,
help=('IoTronic connection failure timer')),
]
autobahn_group = cfg.OptGroup(
name='autobahn', title='Autobahn options'
)
CONF.register_group(autobahn_group)
CONF.register_opts(autobahn_opts, group=autobahn_group)
# Options registration
logging.register_options(CONF)
DOMAIN = "s4t-lightning-rod"
CONF(project='iotronic')
logging.setup(CONF, DOMAIN)
# Logging setup
txaio.start_logging(level=str(CONF.log_level))
global SESSION
SESSION = None
global lr_cty
lr_cty = {}
global wport
wport = None
global board
board = None
from threading import Timer
global connFailure
connFailure = None
global connFailureBoot
connFailureBoot = None
reconnection = False
RPC = {}
RPC_devices = {}
RPC_proxies = {}
zombie_alert = True
# ASYNCIO
global loop
loop = None
component = None
RUNNER = None
connected = False
global MODULES
MODULES = {}
class LightningRod(object):
def __init__(self):
"""
LogoLR()
LOG.info(' - version: ' +
str(utils.get_version("iotronic-lightningrod")))
LOG.info(' - PID: ' + str(os.getpid()))
LOG.info("LR available modules: ")
for ep in pkg_resources.iter_entry_points(group='s4t.modules'):
LOG.info(" - " + str(ep))
logging.register_options(CONF)
DOMAIN = "s4t-lightning-rod"
CONF(project='iotronic')
logging.setup(CONF, DOMAIN)
if CONF.debug:
txaio.start_logging(level="debug")
"""
self.w = None
# Manage LR exit signals
signal.signal(signal.SIGINT, self.stop_handler)
LogoLR()
LOG.info('Lightning-rod: ')
LOG.info(' - version: ' +
str(utils.get_version("iotronic-lightningrod")))
LOG.info(' - PID: ' + str(os.getpid()))
LOG.info(" - Home: " + CONF.lightningrod_home)
if (CONF.log_file == "None"):
LOG.info(' - Log file: not specified!')
else:
LOG.info(' - Log file: ' + CONF.log_file)
LOG.info(" - Log level: " + str(CONF.log_level))
LOG.info('Autobahn: ')
LOG.info(" - Alive Check timer: " + str(CONF.autobahn.alive_timer) +
" seconds")
LOG.info(" - RPC-Alive Check timer: "
+ str(CONF.autobahn.rpc_alive_timer) + " seconds")
LOG.info(" - Connection RPC timer: " + str(
CONF.autobahn.connection_timer) + " seconds")
LOG.info(" - Connection Faliure timeout: " + str(
CONF.autobahn.connection_failure_timer) + " seconds")
global board
board = Board()
# Start REST server
singleModuleLoader("rest", session=None)
if(board.status == "first_boot"):
os.system("pkill -f 'node /usr/bin/wstun'")
LOG.debug("OLD tunnels cleaned!")
print("OLD tunnels cleaned!")
LOG.info("LR FIRST BOOT: waiting for first configuration...")
while (board.status == "first_boot"):
time.sleep(5)
# LR was configured and we have to load its new configuration
board.loadSettings()
# Start timer checks on wamp connection
def timeout():
LOG.warning("WAMP Connection failure timer onBoot: EXPIRED")
lr_utils.LR_restart()
global connFailureBoot
connFailureBoot = Timer(
CONF.autobahn.connection_failure_timer, timeout
)
connFailureBoot.start()
LOG.info("WAMP Connection failure timer onBoot: STARTED")
# Start Wamp Manager
self.w = WampManager(board.wamp_config)
self.w.start()
def stop_handler(self, signum, frame):
try:
zombie_alert = False # No zombie alert activation
LOG.info("LR is shutting down...")
if self.w != None:
self.w.stop()
Bye()
except Exception as e:
LOG.error("Error closing LR")
class WampManager(object):
"""WAMP Manager: through this LR manages the connection to Crossbar server.
"""
def __init__(self, wamp_conf):
# wampConnect configures and manages the connection to Crossbar server.
wampConnect(wamp_conf)
def start(self):
LOG.info(" - starting Lightning-rod WAMP server...")
try:
if(board.status != "url_wamp_error"):
global loop
loop = asyncio.get_event_loop()
component.start(loop)
loop.run_forever()
except Exception as err:
LOG.error(" - Error starting asyncio-component: " + str(err))
def stop(self):
LOG.info("Stopping WAMP agent server...")
# Canceling pending tasks and stopping the loop
asyncio.gather(*asyncio.Task.all_tasks()).cancel()
LOG.info("WAMP server stopped!")
def iotronic_status(board_status):
if (board_status != "first_boot") \
and (board_status != "already-registered") \
and (board_status != "url_wamp_error"):
# WS ALIVE
try:
alive = asyncio.run_coroutine_threadsafe(
wamp_singleCheck(SESSION),
loop
)
alive = alive.result()
except Exception as e:
LOG.error(" - Iotronic check: " + str(e))
alive = e
else:
alive = "Not connected!"
return alive
def wampNotify(session, board, w_msg, subject):
rpc = str(board.agent) + u'.stack4things.notify_result'
async def wampCall(session, board, wm, rpc, action):
w_msg = None
try:
with timeoutRPC(seconds=10, action=action):
res = await session.call(
rpc,
board_uuid=board.uuid,
wampmessage=wm
)
w_msg = WM.deserialize(res)
except exception.ApplicationError as e:
LOG.error(" - wampCall RPC error: " + str(e))
LOG.debug(
" - Notify result '" + subject + "': "
+ str(w_msg.result) + " - " + str(w_msg.message)
)
return w_msg
res = asyncio.run_coroutine_threadsafe(
wampCall(session, board, w_msg, rpc, "notify_result"),
loop
).result()
return res
async def wamp_singleCheck(session):
try:
# LOG.debug("ALIVE sending...")
with timeoutALIVE(
seconds=CONF.autobahn.rpc_alive_timer, action="ws_alive"):
res = await session.call(
str(board.agent) + u'.stack4things.wamp_alive',
board_uuid=board.uuid,
board_name=board.name
)
LOG.debug("WampCheck attempt " + str(res))
except exception.ApplicationError as e:
LOG.error(" - Iotronic Connection RPC error: " + str(e))
return res
async def wamp_checks(session):
while (True):
try:
# LOG.debug("ALIVE sending...")
with timeoutALIVE(
seconds=CONF.autobahn.rpc_alive_timer, action="ws_alive"):
res = await session.call(
str(board.agent) + u'.stack4things.wamp_alive',
board_uuid=board.uuid,
board_name=board.name
)
LOG.debug("WampCheck attempt " + str(res))
except exception.ApplicationError as e:
LOG.error(" - Iotronic Connection RPC error: " + str(e))
# Iotronic is offline the board can not call
# the "stack4things.alive" RPC.
# The board will disconnect from WAMP agent and retry later.
global reconnection
reconnection = True
lr_utils.destroyWampSocket()
try:
await asyncio.sleep(CONF.autobahn.alive_timer)
except Exception as e:
LOG.warning(" - asyncio alert: " + str(e))
async def IotronicLogin(board, session, details):
"""Function called to connect the board to Iotronic.
The board:
1. logs in to Iotronic
2. loads the modules
:param board:
:param session:
:param details:
"""
LOG.info("IoTronic Authentication:")
global reconnection
try:
rpc = str(board.agent) + u'.stack4things.connection'
with timeoutRPC(seconds=CONF.autobahn.connection_timer, action=rpc):
res = await session.call(
rpc,
uuid=board.uuid,
session=details.session,
info={
"lr_version": str(
utils.get_version("iotronic-lightningrod")
),
"connectivity": lr_cty
}
)
w_msg = WM.deserialize(res)
if w_msg.result == WM.SUCCESS:
LOG.info(" - Access granted to Iotronic.")
# WS ALIVE
asyncio.run_coroutine_threadsafe(wamp_checks(session), loop)
# LOADING BOARD MODULES
try:
modulesLoader(session)
except Exception as e:
LOG.warning("WARNING - Could not load modules: " + str(e))
lr_utils.LR_restart()
# Reset flag to False
# reconnection = False
else:
Bye()
except exception.ApplicationError as e:
LOG.error(" - Iotronic Connection RPC error: " + str(e))
# Iotronic is offline the board can not call
# the "stack4things.connection" RPC.
# The board will disconnect from WAMP agent and retry later.
reconnection = True
# We restart Lightning-rod if RPC 'stack4things.connection' is not
# available, this means Wagent is unreachable
lr_utils.LR_restart()
except Exception as e:
LOG.warning("Iotronic board connection error: " + str(e))
reconnection = True
# We restart Lightning-rod if RPC 'stack4things.connection'
# returns generic errors
lr_utils.LR_restart()
def wampConnect(wamp_conf):
"""WAMP connection procedures.
:param wamp_conf: WAMP configuration from settings.json file
"""
LOG.info("WAMP connection precedures:")
try:
LOG.info(
"WAMP status @ boot:" +
"\n- board = " + str(board.status) +
"\n- reconnection = " + str(reconnection) +
"\n- connected = " + str(connected)
)
wamp_transport = wamp_conf['url']
wurl_list = wamp_transport.split(':')
is_wss = False
if wurl_list[0] == "wss":
is_wss = True
whost = wurl_list[1].replace('/', '')
global wport
wport = int(wurl_list[2].replace('/', ''))
if is_wss and CONF.skip_cert_verify:
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
wamp_transport = [
{
"url": wamp_transport,
"max_retries": -1,
"serializers": ["json"],
"endpoint": {
"type": "tcp",
"host": whost,
"port": wport,
"tls": ctx
},
},
]
# LR creates the Autobahn Asyncio Component that points to the
# WAMP Agent (main/registration agent)
global component
component = Component(
transports=wamp_transport,
realm=wamp_conf['realm']
)
# To manage the registration stage: we got the info for the main
# WAMP agent and LR is going to connect to it starting the Component
# with the new WAMP configuration.
if connected == False and board.status == "registered" \
and reconnection == False:
try:
component.start(loop)
except Exception as err:
LOG.error(" - Error connecting asyncio-component: " + str(err))
@component.on_join
async def join(session, details):
"""Execute the following procedures when the board connects
to Crossbar.
:param details: WAMP session details
"""
global wport
global lr_cty
sock_bundle = lr_utils.get_socket_info(wport)
if sock_bundle == "N/A":
lr_cty = {}
else:
lr_cty['iface'] = sock_bundle[0]
lr_cty['local_ip'] = sock_bundle[1]
lr_cty['mac'] = sock_bundle[2]
print(" - Selected NIC: " + str(lr_cty))
global connected
connected = True
# LIGHTNING-ROD STATES:
# - REGISTRATION STATE: the first connection to Iotronic
# - FIRST CONNECTION: the board become operative after registration
# - LIGHTNING-ROD BOOT: the first connection to WAMP
# after Lightning-rod starting
# - WAMP RECOVERY: when the established WAMP connection fails
global reconnection
# reconnection flag is False when the board is:
# - LIGHTNING-ROD BOOT
# - REGISTRATION STATE
# - FIRST CONNECTION
#
# reconnection flag is True when the board is:
# - WAMP RECOVERY
global SESSION
SESSION = session
# LOG.debug(" - session: " + str(details))
board.session_id = details.session
# Clean Connection WAMP timers ------------------------------------
global connFailure
if connFailure != None:
LOG.warning(
"WAMP Connection Failure timer: CANCELLED (onJoin)"
)
connFailure.cancel()
global connFailureBoot
if connFailureBoot != None:
LOG.warning(
"WAMP Connection Failure timer onBoot: CANCELLED (onJoin)"
)
connFailureBoot.cancel()
# -----------------------------------------------------------------
LOG.info(" - Joined in realm " + board.wamp_config['realm'] + ":")
LOG.info(" - WAMP Agent: " + str(board.agent))
print(" - WAMP Agent: " + str(board.agent) + " - "
+ str(wamp_conf['url']))
LOG.info(" - Session ID: " + str(board.session_id))
print(" - Session ID: " + str(board.session_id))
LOG.info(" - Board status: " + str(board.status))
if sock_bundle == "N/A":
LOG.info(" - Socket info:" + str(sock_bundle))
else:
LOG.info(" - Socket info: %s %s %s",
str(sock_bundle[0]),
str(sock_bundle[1]),
str(sock_bundle[2])
)
if reconnection is False:
if board.uuid is None:
######################
# REGISTRATION STATE #
######################
# If in the LR configuration file there is not the
# Board UUID specified it means the board is a new one
# and it has to call IoTronic in order to complete
# the registration.
try:
LOG.info(" - Board needs to be registered.")
rpc = u'stack4things.register'
with timeoutRPC(seconds=5, action=rpc):
res = await session.call(
rpc,
code=board.code,
session=board.session_id
)
w_msg = WM.deserialize(res)
# LOG.info(" - Board registration result: \n" +
# json.loads(w_msg.message, indent=4))
if w_msg.result == WM.SUCCESS:
LOG.info("Registration authorized by IoTronic:\n"
+ str(w_msg.message))
# the 'message' field contains
# the board configuration to load
board.setConf(w_msg.message)
# We need to disconnect the client from the
# registration-agent in order to reconnect
# to the WAMP agent assigned by Iotronic
# at the provisioning stage
LOG.info(
"\n\nDisconnecting from Registration Agent "
"to load new settings...\n\n")
# We restart Lightning-rod if RPC
# 'stack4things.connection' is not available,
# this means Wagent is unreachable
lr_utils.LR_restart()
else:
LOG.error("Registration denied by Iotronic - " +
"board already registered: "
+ str(w_msg.message))
board.status = "already-registered"
# Bye()
except exception.ApplicationError as e:
LOG.error("IoTronic registration error: " + str(e))
# Iotronic is offline the board can not call the
# "stack4things.connection" RPC. The board will
# disconnect from WAMP agent and retry later.
# TO ACTIVE BOOT CONNECTION RECOVERY MODE
reconnection = True
# We restart Lightning-rod if RPC
# 'stack4things.connection' is not available,
# this means Wagent is unreachable
lr_utils.LR_restart()
except Exception as e:
LOG.warning(
" - Board registration call error: " + str(e))
Bye()
else:
if board.status == "registered":
####################
# FIRST CONNECTION #
####################
# In this case we manage the first connection
# after the registration stage:
# Lightining-rod sets its status to "operative"
# completing the provisioning and configuration stage.
LOG.info("\n\n\nBoard is becoming operative...\n\n\n")
board.updateStatus("operative")
board.loadSettings()
LOG.info("WAMP status @ first connection:" +
"\n- board = " + str(board.status) +
"\n- reconnection = " + str(reconnection) +
"\n- connected = " + str(connected)
)
await IotronicLogin(board, session, details)
elif board.status == "operative":
######################
# LIGHTNING-ROD BOOT #
######################
# After join to WAMP agent, Lightning-rod will:
# - authenticate to Iotronic
# - load the enabled modules
# The board will keep at this stage until
# it will succeed to connect to Iotronic.
await IotronicLogin(board, session, details)
else:
LOG.error("Wrong board status '" + board.status + "'.")
Bye()
else:
#################
# WAMP RECOVERY #
#################
LOG.info("IoTronic connection recovery:")
try:
rpc = str(board.agent) + u'.stack4things.connection'
with timeoutRPC(
seconds=CONF.autobahn.connection_timer, action=rpc
):
res = await session.call(
rpc,
uuid=board.uuid,
session=details.session,
info={
"lr_version": str(
utils.get_version("iotronic-lightningrod")
),
"connectivity": lr_cty
}
)
w_msg = WM.deserialize(res)
if w_msg.result == WM.SUCCESS:
LOG.info(" - Access granted to Iotronic (recovery).")
# LOADING BOARD MODULES
# If the board is in WAMP connection recovery state
# we need to register again the RPCs of each module
try:
moduleReloadInfo(session)
# Reset flag to False
reconnection = False
LOG.info("WAMP Session Recovered!")
LOG.info("\n\nListening...\n\n")
# WS ALIVE
asyncio.run_coroutine_threadsafe(
wamp_checks(session),
loop
)
except Exception as e:
LOG.warning(
"WARNING - Could not reload modules: "
+ str(e))
Bye()
else:
LOG.error("Access to IoTronic denied: "
+ str(w_msg.message))
Bye()
except exception.ApplicationError as e:
LOG.error("IoTronic connection error:\n" + str(e))
# Iotronic is offline the board can not call
# the "stack4things.connection" RPC.
# The board will disconnect from WAMP agent and retry later
# TO ACTIVE WAMP CONNECTION RECOVERY MODE
reconnection = False
# We restart Lightning-rod if RPC 'stack4things.connection'
# is not available, this means Wagent is unreachable
lr_utils.LR_restart()
except Exception as e:
LOG.warning("Board connection error after WAMP recovery: "
+ str(e))
Bye()
@component.on_leave
async def onLeave(session, details):
LOG.warning("WAMP Session Left: reason = " + str(details.reason))
@component.on_connectfailure
async def onConnectFailure(session, fail_msg):
LOG.warning("WAMP Connection Failure: " + str(fail_msg))
LOG.warning(" - timeout set @ " +
str(CONF.autobahn.connection_failure_timer))
global connFailure
if connFailure != None:
LOG.warning("WAMP Connection Failure timer: CANCELLED")
connFailure.cancel()
def timeout():
LOG.warning("WAMP Connection Failure timer: EXPIRED")
lr_utils.LR_restart()
connFailure = Timer(
CONF.autobahn.connection_failure_timer, timeout
)
connFailure.start()
LOG.warning("WAMP Connection Failure timer: STARTED")
@component.on_disconnect
async def onDisconnect(session, was_clean):
"""Procedure triggered on WAMP connection lost.
:param session:
:param was_clean:
:return:
"""
LOG.warning('WAMP Transport Left: was_clean = ' + str(was_clean))
global connected
connected = False
global reconnection
LOG.info(
"WAMP status on disconnect:" +
"\n- board = " + str(board.status) +
"\n- reconnection = " + str(reconnection) +
"\n- connected = " + str(connected)
)
board.session_id = "N/A"
if board.status == "operative" and reconnection is False:
#################
# WAMP RECOVERY #
#################
# we need to recover wamp session and
# we set reconnection flag to True in order to activate
# the module-RPCs registration procedure for each module
reconnection = True
# LR needs to reconncet to WAMP
if not connected:
LOG.warning(".............WAMP DISCONNECTION.............")
LOG.info(
"WAMP status on disconnect:" +
"\n- board = " + str(board.status) +
"\n- reconnection = " + str(reconnection) +
"\n- connected = " + str(connected)
)
# component.start(loop)
elif board.status == "operative" and reconnection is True:
######################
# LIGHTNING-ROD BOOT #
######################
# At this stage if the reconnection flag was set to True
# it means that we forced the reconnection procedure
# because of the board is not able to connect to IoTronic
# calling "stack4things.connection" RPC...
# it means IoTronic is offline!
# We need to reset the reconnection flag to False in order to
# do not enter in module-RPCs registration procedure...
# At this stage the board tries to reconnect to
# IoTronic until it will come online again.
reconnection = False
# LR needs to reconncet to WAMP
LOG.warning(".............WAMP DISCONNECTION.............")
LOG.info("WAMP status on disconnect:" +
"\n- board = " + str(board.status) +
"\n- reconnection = " + str(reconnection) +
"\n- connected = " + str(connected)
)
# component.start(loop)
elif (board.status == "registered"):
######################
# REGISTRATION STATE #
######################
# LR was disconnected from Registration Agent
# in order to connect it to the assigned WAMP Agent.
LOG.debug("\n\nReconnecting after registration...\n\n")
# LR load the new configuration and gets the new WAMP Agent
board.loadSettings()
# LR has to connect to the assigned WAMP Agent
wampConnect(board.wamp_config)
else:
LOG.error("Reconnection wrong status!")
except IndexError as err:
LOG.error(" - Error parsing WAMP url: " + str(err))
LOG.error(" --> port or address not specified")
board.status = "url_wamp_error"
except Exception as err:
LOG.error(" - WAMP connection error: " + str(err))
# Bye()
def moduleWampRegister(session, meth_list):
"""This function register for each module methods the relative RPC.
:param session:
:param meth_list:
"""
if len(meth_list) == 2:
LOG.info(" - No procedures to register!")
else:
for meth in meth_list:
# We don't considere the "__init__", "finalize" and
# "restore" methods
if (meth[0] != "__init__") & (meth[0] != "finalize") \
& (meth[0] != "restore"):
rpc_addr = u'iotronic.' + str(board.session_id) + '.' + \
board.uuid + '.' + meth[0]
if not meth[0].startswith('_'):
session.register(meth[1], rpc_addr)
LOG.info(" --> " + str(meth[0]))
def singleModuleLoader(module_name, session=None):
ep = []
for ep in pkg_resources.iter_entry_points(group='s4t.modules'):
# LOG.info(" - " + str(ep))
pass
if not ep:
LOG.info("No modules available!")
sys.exit()
else:
modules = extension.ExtensionManager(
namespace='s4t.modules',
# invoke_on_load=True,
# invoke_args=(session,),
)
LOG.info('Module "' + module_name + '" loading:')
for ext in modules.extensions:
if (ext.name == 'rest'):
mod = ext.plugin(board, session)
global MODULES
MODULES[mod.name] = mod
# Methods list for each module
meth_list = inspect.getmembers(mod, predicate=inspect.ismethod)
global RPC
RPC[mod.name] = meth_list
if len(meth_list) == 3:
# there are at least two methods for each module:
# "__init__" and "finalize"
LOG.info(" - No RPC to register for "
+ str(ext.name) + " module!")
else:
if(session != None):
LOG.info(" - RPC list of " + str(mod.name) + ":")
moduleWampRegister(SESSION, meth_list)
# Call the finalize procedure for each module
mod.finalize()
def modulesLoader(session):
"""Modules loader method thorugh stevedore libraries.
:param session:
"""
LOG.info("Available modules: ")
ep = []
for ep in pkg_resources.iter_entry_points(group='s4t.modules'):
LOG.info(" - " + str(ep))
if not ep:
LOG.info("No modules available!")
sys.exit()
else:
modules = extension.ExtensionManager(
namespace='s4t.modules',
# invoke_on_load=True,
# invoke_args=(session,),
)
LOG.info('Modules to load:')
for ext in modules.extensions:
LOG.debug(ext.name)
if (ext.name == 'gpio') & (board.type == 'server'):
LOG.info("- GPIO module disabled for 'server' devices")
else:
if ext.name != "rest":
mod = ext.plugin(board, session)
global MODULES
MODULES[mod.name] = mod
# Methods list for each module
meth_list = inspect.getmembers(
mod, predicate=inspect.ismethod
)
global RPC
RPC[mod.name] = meth_list
if len(meth_list) == 3:
# there are at least two methods for each module:
# "__init__" and "finalize"
LOG.info(" - No RPC to register for "
+ str(ext.name) + " module!")
else:
LOG.info(" - RPC list of " + str(mod.name) + ":")
moduleWampRegister(SESSION, meth_list)
# Call the finalize procedure for each module
mod.finalize()
LOG.info("Lightning-rod modules loaded.")
LOG.info("\n\nListening...")
def moduleReloadInfo(session):
"""This function is used in the reconnection stage to register
again the RPCs of each module and for device.
:param session: WAMP session object.
"""
LOG.info("\n\nModules reloading after WAMP recovery...\n\n")
try:
# Call module restore procedures and
# register RPCs for each Lightning-rod module
for mod_name in MODULES:
LOG.info("- Registering RPCs for module " + str(mod_name))
moduleWampRegister(session, RPC[mod_name])
LOG.info("- Restoring module " + str(mod_name))
MODULES[mod_name].restore()
# Register RPCs for the device
for dev in RPC_devices:
LOG.info("- Registering RPCs for device " + str(dev))
moduleWampRegister(session, RPC_devices[dev])
except Exception as err:
LOG.warning("Board modules reloading error: " + str(err))
lr_utils.LR_restart()
def Bye():
LOG.info("Bye!")
os._exit(1)
def LogoLR():
LOG.info('##############################')
LOG.info(' Stack4Things Lightning-rod')
LOG.info('##############################')
def main():
LightningRod()