def apply_settings(self):
"""If settings are changed this is the final step before the settings are available to use"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.logger.error("Settings rejected/not found: %s %s" %
(rejected, not_found))
SettingsBase.commit_settings(self, accepted)
# other parameter
self.gateway_v1_backward_compatibility = SettingsBase.get_setting(
self, 'gateway_v1_backward_compatibility')
self.destinations = SettingsBase.get_setting(self, 'destinations')
update_logging_level(self.logger,
SettingsBase.get_setting(self, 'log_level'))
# check if xbeerawout_channel must be changed
if 'xbeerawout_interface' in accepted:
# reinitialization will be done at first message send
self.xbeerawout_channel = None
return (accepted, rejected, not_found)
def apply_settings(self):
"""Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.logger.warn(
"%s(%s): settings rejected/not found: %s/%s" %
(self.__class__.__name__, self.__name, rejected, not_found))
SettingsBase.commit_settings(self, accepted)
new_level_string = SettingsBase.get_setting(self, 'log_level')
try:
# The syntax of the setting has already been verified
new_level = eval('logging.' + new_level_string)
self.logger.setLevel(new_level)
except Exception:
# new_level_string is not an attribube of the logging package
self.logger.error(
'Setting change error for log_level: should be DEBUG, ERROR, ...'
)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "TimingService(%s) Settings rejected/not found: %s %s" % (
self.__name, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
# Tear down and rebuild annotation system, this does mean that
# reconfiguration will cause a window where stale data will
# not be reported at the time where it technically becomes
# stale under either configuration necessarily.
self._destroy_timers()
self._create_timers()
self._enroll_channel_sources()
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# There were problems with settings, terminate early:
print "idigi_db (%s): Settings rejected/not found: %s %s" % \
(self.__name, rejected, not_found)
return (accepted, rejected, not_found)
# Verify that if we are on the Digi ConnectPort X3, that the user
# doesn't have the secure option set to True.
# If they do, we MUST bail here and also warn the user that the
# Digi ConnectPort X3 cannot do secure/encrypted idigi connections.
if accepted['secure'] == True and get_platform_name() == 'digix3':
print "idigi_db (%s): The Digi ConnectPort X3 product cannot " \
"do secure/encrypted connections to the iDigi Server. " \
"Please set the 'secure' option to False!" % \
(self.__name)
rejected['secure'] = accepted['secure']
del accepted['secure']
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
# xbee_manager_name = SettingsBase.get_setting(self, "xbee_device_manager")
dm = self.__core.get_service("device_driver_manager")
self.__xbee_manager = dm.instance_get("xbee_device_manager")
self.__last_upload_time = 0
self.repeat()
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
try:
if not threading.Thread.isAlive(self):
return
except:
return
if 'update_rate' in accepted and \
accepted['update_rate'] > SHUTDOWN_WAIT:
self.__tracer.warning('Long update_rate setting may ' +
'interfere with shutdown of DIA.')
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
# verify exclusive issues
if(accepted['poll_clean_minutes'] > 0):
# then we have exclusive issues to settle
if(accepted['sleep']):
# cannot sleep with clean_minutes active
print "XBeeWatchport: 'sleep' cannot be True if poll_clean_minutes is used."
rejected['sleep'] = accepted['sleep']
del accepted['sleep']
# over-ride / force sample_rate to match clean_minutes
accepted['sample_rate_ms'] = \
accepted['poll_clean_minutes'] * 60000
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
print "Settings rejected/not found: %s %s" % (rejected, not_found)
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
self._tracer.calls("XBeeAIO.apply_settings()")
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self._tracer.error("Settings rejected/not found: %s %s", rejected,
not_found)
return (accepted, rejected, not_found)
# Verify that the sample predelay time when added to the awake time
# is not over 0xffff.
if accepted['sample_predelay'] + accepted['awake_time_ms'] > 0xffff:
self._tracer.error(
"The awake_time_ms value (%d) " +
"and sample_predelay value (%d) " +
"when added together cannot exceed " + "65535.",
accepted['sample_predelay'], accepted['awake_time_ms'])
rejected['awake_time_ms'] = accepted['awake_time_ms']
del accepted['awake_time_ms']
rejected['sample_predelay'] = accepted['sample_predelay']
del accepted['sample_predelay']
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""If settings are changed this is the final step before the settings are available to use"""
self.logger.info("apply_settings")
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.logger.error ("Settings rejected/not found: %s %s" % (rejected, not_found))
SettingsBase.commit_settings(self, accepted)
# other parameter
self.gateway_v1_backward_compatibility = SettingsBase.get_setting(self, 'gateway_v1_backward_compatibility')
self.destinations = SettingsBase.get_setting(self, 'destinations')
self.msg_size_on_7_bits = SettingsBase.get_setting(self, 'msg_size_on_7_bits')
update_logging_level (self.logger, SettingsBase.get_setting(self, 'log_level'))
#configuration of the modem handler
self.m10_handler.SC_Set_Library_Default_Settings(
desired_gateway=m10_sc_api.DESIRED_GATEWAY_VALUES[SettingsBase.get_setting(self, 'desired_gateway')],
def_polled=m10_sc_api.SC_POLL_MODE_VALUES[SettingsBase.get_setting(self, 'def_polled')],
def_ack_level=m10_sc_api.ACK_LEVEL_VALUES[SettingsBase.get_setting(self, 'def_ack_level')],
def_rep_or_ind=transform_in_usable_OR(SettingsBase.get_setting(self, 'def_rep_or_ind')),
def_msg_or_ind=transform_in_usable_OR(SettingsBase.get_setting(self, 'def_msg_or_ind')),
def_priority=m10_sc_api.PRIORITY_LVL[SettingsBase.get_setting(self, 'def_priority')],
def_msg_body_type=m10_sc_api.MSG_BODY_TYPE_VALUES[SettingsBase.get_setting(self, 'def_msg_body_type')],
def_serv_type=m10_sc_api.REPORTS_SERVICE_TYPE_VALUES[SettingsBase.get_setting(self, 'def_serv_type')],
gwy_search_mode=m10_sc_api.GWY_SEARCH_MODE_VALUES[SettingsBase.get_setting(self, 'gwy_search_mode')]
)
if self.m10_handler.serial_is_open():
#we send the configuration to the modem
self.m10_handler.SC_Write_to_modem_Library_Default_Settings()
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
try:
if not threading.Thread.isAlive(self):
return
except:
return
if 'update_rate' in accepted and \
accepted['update_rate'] > SHUTDOWN_WAIT:
self.__tracer.warning('Long update_rate setting may ' +
'interfere with shutdown of Dia.')
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.error("Settings rejected/not found: %s %s",
rejected, not_found)
return (accepted, rejected, not_found)
# Verify that the sample predelay time when added to the awake time
# is not over 0xffff.
if accepted['sample_predelay'] + accepted['awake_time_ms'] > 0xffff:
self.__tracer.error("The awake_time_ms value (%d) " +
"and sample_predelay value (%d) " +
"when added together cannot exceed 65535.",
self.__name, accepted['sample_predelay'],
accepted['awake_time_ms'])
rejected['awake_time_ms'] = accepted['awake_time_ms']
del accepted['awake_time_ms']
rejected['sample_predelay'] = accepted['sample_predelay']
del accepted['sample_predelay']
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("settings rejected/not found: %s/%s",
rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "Settings rejected/not found: %s %s" % (rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("settings rejected/not found: %s/%s", rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.error("Settings rejected/not found: %s %s", \
rejected, not_found)
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.error("Settings rejected/not found: %s %s", \
rejected, not_found)
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
""" Apply settings as they are defined by the configuration file """
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "Settings rejected/not found: %s %s" % (rejected, not_found)
self.__channels = accepted['channels']
self.__update_rate = accepted['update_rate']
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "Settings rejected/not found: %s %s" % (rejected, not_found)
if accepted['page'].startswith('/'):
# trim leading / if present:
accepted['page'] = accepted['page'][1:]
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""
Apply settings as they are defined by the configuration file.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "Settings rejected/not found: %s %s" % (rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("Settings rejected/not found: %s %s", rejected,
not_found)
SettingsBase.commit_settings(self, accepted)
update_logging_level(self.logger,
SettingsBase.get_setting(self, 'log_level'))
return (accepted, rejected, not_found)
def apply_settings(self):
"""Called when new configuration settings are available."""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.error("Settings rejected/not found: %s %s",
rejected, not_found)
else:
SettingsBase.commit_settings(self, accepted)
self.__tracer.debug("Settings accepted: %s", accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("Settings rejected/not found: %s %s", rejected,
not_found)
if accepted['page'].startswith('/'):
# trim leading / if present:
accepted['page'] = accepted['page'][1:]
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""
Apply settings as they are defined by the configuration file.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "Settings rejected/not found: %s %s" % (rejected, not_found)
SettingsBase.commit_settings(self, accepted)
update_logging_level(self.__logger,
SettingsBase.get_setting(self, 'log_level'))
return (accepted, rejected, not_found)
def apply_settings(self):
"""Called when new configuration settings are available."""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
print "%s: Settings rejected/not found: %s %s" % \
(self.show_name, rejected, not_found)
else:
SettingsBase.commit_settings(self, accepted)
# print "%s: Settings accepted: %s" % (self.show_name, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("Settings rejected/not found: %s %s",
rejected, not_found)
if (('update_rate' in accepted) and
(accepted['update_rate'] > SHUTDOWN_WAIT)):
self.__tracer.warning("Long update_rate setting may " +
"interfere with shutdown of Dia")
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("Settings rejected/not found: %s %s", rejected,
not_found)
if (('update_rate' in accepted)
and (accepted['update_rate'] > SHUTDOWN_WAIT)):
self.__tracer.warning("Long update_rate setting may " +
"interfere with shutdown of DIA")
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.error("Settings rejected/not found: %s %s", \
rejected, not_found)
return (accepted, rejected, not_found)
if accepted['clients'].has_key('instance_list'):
clients_list = accepted['clients']['instance_list']
else:
self.__tracer.error("Attempt to retrieve 'clients' " \
"list failed...")
rejected['clients'] = accepted['clients']
del accepted['clients']
return (accepted, rejected, not_found)
if accepted['updates'].has_key('instance_list'):
updates_list = accepted['updates']['instance_list']
else:
updates_list = {}
if accepted['alarms'].has_key('instance_list'):
alarms_list = accepted['alarms']['instance_list']
else:
alarms_list = {}
ret = self.__verify_valid_client_in_list(updates_list, clients_list)
if ret == False:
self.__tracer.error("A client referenced in the " + \
"'updates' setting does not exist in the 'clients' setting")
rejected['updates'] = accepted['updates']
del accepted['updates']
return (accepted, rejected, not_found)
ret = self.__verify_valid_client_in_list(alarms_list, clients_list)
if ret == False:
self.__tracer.error("A client referenced in the " \
"'alarms' setting does not exist in the 'clients' setting")
rejected['alarms'] = accepted['alarms']
del accepted['alarms']
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.error("Settings rejected/not found: %s %s", \
rejected, not_found)
return (accepted, rejected, not_found)
if accepted['clients'].has_key('instance_list'):
clients_list = accepted['clients']['instance_list']
else:
self.__tracer.error("Attempt to retrieve 'clients' " \
"list failed...")
rejected['clients'] = accepted['clients']
del accepted['clients']
return (accepted, rejected, not_found)
if accepted['updates'].has_key('instance_list'):
updates_list = accepted['updates']['instance_list']
else:
updates_list = {}
if accepted['alarms'].has_key('instance_list'):
alarms_list = accepted['alarms']['instance_list']
else:
alarms_list = {}
ret = self.__verify_valid_client_in_list(updates_list, clients_list)
if ret == False:
self.__tracer.error("A client referenced in the " + \
"'updates' setting does not exist in the 'clients' setting")
rejected['updates'] = accepted['updates']
del accepted['updates']
return (accepted, rejected, not_found)
ret = self.__verify_valid_client_in_list(alarms_list, clients_list)
if ret == False:
self.__tracer.error("A client referenced in the " \
"'alarms' setting does not exist in the 'clients' setting")
rejected['alarms'] = accepted['alarms']
del accepted['alarms']
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
'''
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
'''
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "Settings rejected/not found: %s %s" % (rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
email_reg = re.compile('[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}',
re.IGNORECASE)
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
## Validate email addresses
if not email_reg.search(accepted['to_address']):
raise Exception("to_address was invalid: %s" %
accepted['to_address'])
if not email_reg.search(accepted['from_address']):
raise Exception("from_address was invalid: %s" %
accepted['from_address'])
## Validate port
try:
if int(accepted['port']) < 1 or (int(accepted['port']) > 65535):
raise Exception("port is an invalid port number %s" %
accepted['port'])
except ValueError:
raise Exception("port is an invalid port number %s" %
accepted['port'])
## Get handle to channel manager, which gives us channel publisher
channel_manager = self.__core.get_service("channel_manager")
channel_publisher = channel_manager.channel_publisher_get()
##Unsubscribe to the 'old' channel if we have subscribed before
if self.monitored_channel is not None:
try:
channel_publisher.unsubscribe(self.monitored_channel,
self.queue_msg)
except ChannelDoesNotExist:
self.__tracer.error(
"The channel %s does not exist, it cannot be unsubscribed to",
self.monitored_channel)
## subscribe to monitored_channel
self.monitored_channel = accepted['monitored_channel']
channel_publisher.subscribe(self.monitored_channel, self.queue_msg)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self._logger.error("Settings rejected/not found: %s %s",
rejected, not_found)
SettingsBase.commit_settings(self, accepted)
update_logging_level (self._logger, SettingsBase.get_setting(self, 'log_level'))
# Get the extended address of the device:
self._extended_address_setting = SettingsBase.get_setting(self, "extended_address")
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print ("%s(%s): settings rejected/not found: %s/%s" %
(self.__class__.__name__, self.__name, rejected, not_found))
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("Settings rejected/not found: %s %s", rejected,
not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("Settings rejected/not found: %s %s", rejected,
not_found)
if PROP_TICK_RATE in accepted and \
accepted[PROP_TICK_RATE] != DEFAULT_TICK_RATE:
self.__tracer.warning(
"tick_rate settings is depreciated, using %d",
DEFAULT_TICK_RATE)
accepted[PROP_TICK_RATE] = DEFAULT_TICK_RATE
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "%s ERROR: some settings are invalid." % self.__name
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""
Apply new settings on this abstract service manager instance.
This function is called by the settings sub-system when there are
new settings available. This method may be overridden. The
default implementation accepts all settings and then calls the
local private function self._reenumerate_services() in order to
start new services. Changes in settings are then committed
to the settings running registry.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
self._reenumerate_services()
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""
Apply new settings on this abstract service manager instance.
This function is called by the settings sub-system when there are
new settings available. This method may be overridden. The
default implementation accepts all settings and then calls the
local private function self._reenumerate_services() in order to
start new services. Changes in settings are then committed
to the settings running registry.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
self._reenumerate_services()
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.__tracer.error("Settings rejected/not found: %s %s",
rejected, not_found)
if PROP_TICK_RATE in accepted and \
accepted[PROP_TICK_RATE] != DEFAULT_TICK_RATE:
self.__tracer.warning("tick_rate settings is depreciated, using %d",
DEFAULT_TICK_RATE)
accepted[PROP_TICK_RATE] = DEFAULT_TICK_RATE
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not found.
"""
self._tracer.calls("DeviceBase.apply_settings()")
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""
Apply settings as they are defined by the configuration file.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self._logger.error("Settings rejected/not found: %s %s", rejected, not_found)
SettingsBase.commit_settings(self, accepted)
update_logging_level (self._logger, SettingsBase.get_setting(self, 'log_level'))
self._dia_channel_name_to_ec_sensor_name_setting_map = SettingsBase.get_setting(self, 'dia_channel_to_ec_sensor')
self._dia_module_name_to_ec_device_public_key_setting_map = SettingsBase.get_setting(self, 'dia_module_to_ec_pub_key')
self._sensor_channel_list_to_subscribe_to_setting = SettingsBase.get_setting(self, 'channels')
self._ec_access_point_pub_key_setting = SettingsBase.get_setting(self, 'ec_access_point_pub_key')
self._incoming_command_channel_setting = SettingsBase.get_setting(self, 'incoming_command_channel')
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.warning("There was an error with the settings. " +
"Attempting to continue.")
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings, and a
dictionary of required settings that were not found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
#if len(rejected) or len(not_found):
if len(not_found):
# Ignore extra settings, but reject if required settings are
# not found
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
""" Apply settings as they are defined by the configuration file """
email_reg = re.compile('[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}', re.IGNORECASE)
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
## Validate email addresses
if not email_reg.search(accepted['to_address']):
raise Exception("to_address was invalid: %s" %accepted['to_address'])
if not email_reg.search(accepted['from_address']):
raise Exception("from_address was invalid: %s" %accepted['from_address'])
## Validate port
try:
if int(accepted['port']) < 1 or (int(accepted['port']) > 65535):
raise Exception("port is an invalid port number %s" %accepted['port'])
except ValueError:
raise Exception("port is an invalid port number %s" %accepted['port'])
## Get handle to channel manager, which gives us channel publisher
cm = self.__core.get_service("channel_manager")
cp = cm.channel_publisher_get()
##Unsubscribe to the 'old' channel if we have subscribed before
if self.monitored_channel is not None:
try:
cp.unsubscribe(self.monitored_channel, self.queue_msg)
except ChannelDoesNotExist:
print "The channel %s does not exist, it cannot be unsubscribed to" % \
(self.monitored_channel)
## subscribe to monitored_channel
self.monitored_channel = accepted['monitored_channel']
cp.subscribe(self.monitored_channel, self.queue_msg)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
print "Settings rejected/not found: %s %s" % (rejected, not_found)
return (accepted, rejected, not_found)
# Verify that the sample predelay time when added to the awake time
# is not over 0xffff.
if accepted['sample_predelay'] + accepted['awake_time_ms'] > 0xffff:
print "XBeeSensor(%s): The awake_time_ms value (%d) "\
"and sample_predelay value (%d) "\
"when added together cannot exceed 65535." % \
(self.__name, accepted['sample_predelay'],\
accepted['awake_time_ms'])
rejected['awake_time_ms'] = accepted['awake_time_ms']
del accepted['awake_time_ms']
rejected['sample_predelay'] = accepted['sample_predelay']
del accepted['sample_predelay']
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
print "ValueService(%s) Settings rejected/not found: %s %s" % (
self.__name, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
# Tear down and rebuild annotation system
self._destroy_existing_annotations()
self._enumerate_channel_settings()
self._enroll_channel_sources()
return (accepted, rejected, not_found)
def apply_settings(self):
"""Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.logger.warn(
"%s(%s): settings rejected/not found: %s/%s" %
(self.__class__.__name__, self.__name, rejected, not_found))
SettingsBase.commit_settings(self, accepted)
update_logging_level(self.logger,
SettingsBase.get_setting(self, 'log_level'))
self._min_delay_between_successive_exchanges_with_waveport = SettingsBase.get_setting(
self, '_min_delay_between_successive_exchanges_with_waveport')
return (accepted, rejected, not_found)
def apply_settings(self):
"""\
Called when new configuration settings are available.
Must return tuple of three dictionaries: a dictionary of
accepted settings, a dictionary of rejected settings,
and a dictionary of required settings that were not
found.
"""
if self.trace:
print 'WirelessSensor(%s) apply_settings' % self.__name
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
print "Settings rejected/not found: %s %s" % (rejected, not_found)
return (accepted, rejected, not_found)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""Commits the settings to the Settings Base"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
class LocalIO(DeviceBase):
"""
This class extends one of our base classes and is intended as an
example of a concrete, example implementation, but it is not itself
meant to be included as part of our developer API. Please consult the
base class documentation for the API and the source code for this file
for an example implementation.
"""
LOCAL_AIO_MODE_CURRENTLOOP = "CurrentLoop"
LOCAL_AIO_MODE_TENV = "TenV"
IO_MAX_CHANNELS = 10
IO_TYPE_NONE = 0
IO_TYPE_ANALOG = 1
IO_TYPE_DIGITAL = 2
def __init__(self, name, core_services):
self.__name = name
self.__core = core_services
## Local State Variables:
self.__xbee_aio_driver = None
self.__xbee_dio_driver = None
self.__analog_channels = []
self.__digital_channels = []
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
## Settings Table Definition:
settings_list = [
Setting(name = 'power', type = Boolean, required = False,
default_value = Boolean("On", STYLE_ONOFF),
verify_function = self.__verify_power_setting),
Setting(name = 'sample_rate_ms', type = int, required = False,
default_value = 60000,
verify_function = lambda x: x >= 100 and x <= 6000000),
Setting(name = 'calibration_rate_ms', type = int, required = False,
default_value = 900000,
verify_function = lambda x: x >= 0),
]
## Channel Properties Definition:
property_list = []
# Dynamically create the rest of our settings based on what the device supports.
for ch in range(0, self.IO_MAX_CHANNELS):
# Attempt to get the channel type.
# If we try to go beyond the amount of supported channels,
# we will get a ValueError exception. If we do, stop our loop.
try:
type = digihw.get_channel_type(ch)
except ValueError:
# we'll hit this once we go past valid count since we support 10
# channels, but likely device like X4H only has 4
# traceback.print_exc()
break
except:
traceback.print_exc()
if type == self.IO_TYPE_ANALOG:
self.__tracer.info("Detected IO channel %d is Analog",
ch + 1)
self.__analog_channels.append(ch)
settings_list.append(Setting(
name = 'channel%d_mode' % (ch + 1),
type=str, required=False,
verify_function = _verify_aio_channel_mode,
default_value = self.LOCAL_AIO_MODE_TENV))
elif type == self.IO_TYPE_DIGITAL:
self.__tracer.info("Detected IO channel %d is Digital",
ch + 1)
self.__digital_channels.append(ch)
settings_list.append(Setting(
name = 'channel%d_dir' % (ch + 1), type = str,
required=False,
default_value='in'))
settings_list.append(Setting(
name = 'channel%d_source' % (ch + 1), type = str,
required = False,
default_value=''))
else:
raise "Unknown IO hardware type channel %d, is %d" % \
((ch + 1), type)
# Finally, on some platforms, the AIO and DIO support is done by
# the XBee radio inside the unit.
#
# If this is the case, we will need to also have the
# 'xbee_device_manager' setting provided to us as well.
if get_platform_name() == 'digix3':
settings_list.append(Setting(name='xbee_device_manager',
type = str, required = True))
self.__xbee_aio_driver = self.__xbee_dio_driver = \
XBeeLocalIO(self, core_services,
self.__analog_channels,
self.__digital_channels)
elif get_platform_name() == 'digiconnect':
settings_list.append(Setting(name='xbee_device_manager',
type = str, required = True))
self.__xbee_aio_driver = self.__xbee_dio_driver = \
XBeeLocalIO(self, core_services,
self.__analog_channels,
self.__digital_channels)
## Initialize the DeviceBase interface:
DeviceBase.__init__(self, self.__name, self.__core,
settings_list, property_list)
## Functions which must be implemented to conform to the DeviceBase
## interface:
def apply_settings(self):
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
# there were problems with settings, terminate early:
self.__tracer.error("Settings rejected/not found: %s %s",
rejected, not_found)
return (accepted, rejected, not_found)
# Walk each setting, and verify the physical channel type
# is the same type the user specified in their config.
for setting in accepted.copy():
if setting[0:7] == "channel":
try:
channel = setting[7]
operation = setting[9:]
type = digihw.get_channel_type(int(channel) - 1)
if type == self.IO_TYPE_ANALOG:
if operation != "mode":
raise ValueError, "Channel mode is not correct"
elif type == self.IO_TYPE_DIGITAL:
if operation != "dir" and operation != "source":
raise ValueError, "Channel mode is not correct"
else:
raise ValueError, "Channel mode is not correct"
except Exception, e:
self.__tracer.error("Unable to parse settings: %s", e)
rejected[setting] = accepted[setting]
del accepted[setting]
SettingsBase.commit_settings(self, accepted)
return (accepted, rejected, not_found)
def apply_settings(self):
"""If settings are changed this is the final step before the settings are available to use"""
SettingsBase.merge_settings(self)
accepted, rejected, not_found = SettingsBase.verify_settings(self)
if len(rejected) or len(not_found):
self.logger.error("Settings rejected/not found: %s %s" %
(rejected, not_found))
SettingsBase.commit_settings(self, accepted)
# reset class variables according to new values
need_to_reset_alwayon_connection = False
# get gateway id
previous_gateway_id = self.gateway_id
gateway_id_setting = SettingsBase.get_setting(
self, 'gateway_id'
) # gateway_id setting is mandatory, so the get_setting will return a valid string
if (gateway_id_setting.lower() == '@sim'):
phone_number = self.retreive_phone_number_from_sim(max_tries=30,
retry_delay=1)
if (phone_number):
self.gateway_id = phone_number
else:
self.gateway_id = gateway_id_setting
else:
self.gateway_id = gateway_id_setting
self.logger.debug('Got gateway id: %s' % self.gateway_id)
# need to reset alwayson connection if gateway id was previously defined and changed
if (previous_gateway_id):
if (previous_gateway_id != self.gateway_id):
need_to_reset_alwayon_connection = True
# other parameter
self.write_channel_name = SettingsBase.get_setting(
self, 'write_channel')
self.read_channel_name = SettingsBase.get_setting(self, 'read_channel')
self.ao_msg_size_on_7_bits = SettingsBase.get_setting(
self, 'ao_msg_size_on_7_bits')
self.server_port = SettingsBase.get_setting(self, 'server_port')
self.server_address = SettingsBase.get_setting(self, 'server_address')
self.activate_tcp_keepalive = SettingsBase.get_setting(
self, 'activate_tcp_keepalive')
update_logging_level(self.logger,
SettingsBase.get_setting(self, 'log_level'))
if (need_to_reset_alwayon_connection):
self.logger.info(
'Some parameter change need a AlwaysON connection reset')
self.close_tcp_connection()
# check if channel must be changed
if 'write_channel' in accepted:
# reinitialization will be done at first message send
self.write_channel = None
return (accepted, rejected, not_found)
