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):
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):
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]
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):
"""\
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:
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]
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):
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):
"""\
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)
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):
"""\
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:
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):
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)
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)
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):
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):
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):
"""
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):
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):
"""\
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):
# 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):
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):
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):
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):
"""\
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):
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):
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):
"""
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):
"""\
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):
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):
"""\
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):
""" 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.
"""
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):
"""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.
"""
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):
"""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)
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)
