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)