def set_prop(self, prop, val=None, save=False): if prop == 'pass_errors': v = val_to_boolean(val) if v is not None: if self.api.pass_errors != v: self.api.pass_errors = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'send_critical': v = val_to_boolean(val) if v is not None: if self.api.send_critical != v: self.api.send_critical = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'src': if isinstance(val, str): code = val elif isinstance(val, dict): try: v = val.copy() if 'name' in v: del v['name'] code = '# SFC\n# auto generated code, ' + \ 'do not modify\n"""\n{}\n"""\n'.format( rapidjson.dumps(v)) + compile_macro_sfc(val) except Exception as e: logging.error( 'Unable to compile macro source for {}: {}'.format( self.oid, e)) return False else: return False try: file_name = eva.core.format_xc_fname( fname=self.action_exec if self.action_exec else '{}.py'. format(self.item_id)) eva.core.prepare_save() with open(file_name, 'w') as fd: fd.write(code) eva.core.finish_save() return True except FunctionFailed: raise except Exception as e: logging.error('Unable to write macro source for {}: {}'.format( self.oid, e)) return False return super().set_prop(prop, val, save)
def update_config(cfg): try: host = cfg.get('msad/host') except LookupError: return logging.debug(f'msad.host = {host}') domain = cfg.get('msad/domain', default='') logging.debug(f'msad.domain = {domain}') ca = cfg.get('msad/ca', default=None) logging.debug(f'msad.ca = {ca}') key_prefix = cfg.get('msad/key-prefix', default=None) logging.debug(f'msad.key_prefix = {key_prefix}') ou = cfg.get('msad/ou', default=_d.msad_ou) logging.debug(f'msad.ou = {ou}') try: cache_time = float(cfg.get('msad/cache-time')) except: cache_time = 86400 logging.debug(f'msad.cache_time = {cache_time}') try: cache_first = val_to_boolean(cfg.get('msad/cache-first')) if cache_first is None: raise ValueError except: cache_first = False logging.debug(f'msad.cache_first = {cache_first}') msad_init(host, domain, ca, key_prefix, ou, cache_time, cache_first)
def load_keys_from_db(): _keys = {} _keys_by_id = {} dbconn = userdb() meta = sa.MetaData() t_apikeys = sa.Table('apikeys', meta, sa.Column('k_id', sa.String(64), primary_key=True), sa.Column('k', sa.String(64)), sa.Column('m', sa.Integer), sa.Column('s', sa.Integer), sa.Column('i', sa.String(1024)), sa.Column('g', sa.String(1024)), sa.Column('i_ro', sa.String(1024)), sa.Column('g_ro', sa.String(1024)), sa.Column('a', sa.String(256)), sa.Column('hal', sa.String(1024)), sa.Column('has', sa.String(1024)), sa.Column('pvt', sa.String(1024)), sa.Column('rpvt', sa.String(1024))) try: meta.create_all(dbconn) except: logging.critical('unable to create apikeys table in db') return _keys, _keys_by_id try: result = dbconn.execute(sql('select * from apikeys')) while True: r = result.fetchone() if not r: break key = APIKey(r.k, r.k_id) key.sysfunc = True if val_to_boolean(r.s) else False for i, v in { 'item_ids': 'i', 'groups': 'g', 'item_ids_ro': 'i_ro', 'groups_ro': 'g_ro', 'allow': 'a', 'pvt_files': 'pvt', 'rpvt_uris': 'rpvt' }.items(): setattr( key, i, list(filter(None, [j.strip() for j in r[v].split(',')]))) _hosts_allow = list( filter(None, [j.strip() for j in r.hal.split(',')])) key.hosts_allow = [IPNetwork(h) for h in _hosts_allow] _hosts_assign = list( filter(None, [x.strip() for x in r.has.split(',')])) key.hosts_assign = \ [ IPNetwork(h) for h in _hosts_assign ] key.dynamic = True key.in_db = True _keys[key.key] = key _keys_by_id[key.key_id] = key except: eva.core.report_userdb_error(raise_exeption=False) return _keys, _keys_by_id
def __init__(self, **kwargs): self.ports = self.phi_cfg.get('port') self.no_pullup = val_to_boolean(self.phi_cfg.get('no_pullup')) self.devices = [] try: self.gpiozero = importlib.import_module('gpiozero') except: self.log_error('gpiozero python module not found') self.ready = False return
def __init__(self, **kwargs): self.host = self.phi_cfg.get('host') self.pw = self.phi_cfg.get('pw') # set logout='skip' to speed up the operations # but keep device bound to UC ip address self.skip_logout = val_to_boolean(self.phi_cfg.get('skip_logout')) self.re_ss = re.compile('sockstates = \[([01,]+)\]') if not self.host or not self.pw: self.ready = False self.lock = threading.Lock()
def set_prop(self, prop, val=None, save=False): if prop == 'enabled': v = val_to_boolean(val) if v is not None: if self.enabled != v: self.enabled = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'macro': if self.macro != val: self.macro = val self.log_set(prop, val) self.set_modified(save) return True elif prop == 'every': if self.every_set != val: self.every_set = val self.log_set(prop, val) self.set_modified(save) self.reschedule() return True elif prop == 'macro_args': if val is not None: if isinstance(val, list): v = val elif isinstance(val, tuple): v = list(val) else: try: v = shlex.split(val) except: v = val.split(' ') else: v = [] self.macro_args = v self.log_set(prop, val) self.set_modified(save) return True elif prop == 'macro_kwargs': if val is None: self.macro_kwargs = {} else: self.macro_kwargs = dict_from_str(val) self.log_set(prop, val) self.set_modified(save) return True return super().set_prop(prop, val, save)
def write_bool(port, reg, values, **kwargs): """ Write boolean values Args: values: a single boolean, list of boolean, list of strings or list of integers """ reg_type, addr = _parse_reg(reg) if not isinstance(values, list) and not isinstance(values, tuple): values = [values] values = [val_to_boolean(x) for x in values] if reg_type == 'c': result = port.write_coils(addr, values, **kwargs) else: raise ValueError(f'Method not supported for register type {reg_type}') if result.isError(): raise RuntimeError('Modbus I/O error') else: return True
def __init__(self, **kwargs): # skip - skip sensor errors (log error and continue) # otherwise if one sensor in a group failed, stop polling others # # may be overriden with skip_errors param in a state request cfg self.skip_err = val_to_boolean(self.lpi_cfg.get('skip_err')) # when polling a sensor group # avg - return avg sensor value # max - return max sensor value # min - return min sensor value # first - return first sensor value unless it's failed # # may be overriden with gpf param in a state request cfg self.gpf = self.lpi_cfg.get('gpf') if \ self.lpi_cfg.get('gpf') is not None else 'avg' # when polling a sensor group, mark sensor as broken if its value is # different from avg on max_diff. Setting variable to 'skip' disables # this feature try: self.max_diff = float(self.lpi_cfg.get('max_diff')) except: self.max_diff = None
def PATCH(self, rtp, k, ii, save, kind, method, for_dir, props): if rtp == 'cvar': return self.set_cvar(k=k, i=ii, **props) elif rtp == 'core': success = False if 'debug' in props: if not self.set_debug(k=k, debug=props['debug']): raise FunctionFailed success = True if 'setup' in props: if not self.setup_mode(k=k, setup=props['setup']): raise FunctionFailed success = True if success: return True else: raise ResourceNotFound elif rtp == 'key': for i, v in props.items(): if not SysAPI.set_key_prop( self, k=k, i=ii, p=i, v=v, save=save): raise FunctionFailed return True elif rtp == 'notifier': if not 'enabled' in props: raise FunctionFailed return self.enable_notifier(k=k, i=ii) if val_to_boolean( props.get('enabled')) else self.disable_notifier(k=k, i=ii) elif rtp == 'runtime': m, e = parse_api_params(props, 'me', '.b') if m is not None: SysAPI.file_put(self, k=k, i=ii, m=m) if e is not None: self.file_set_exec(k=k, i=ii, e=e) return True elif rtp == 'user': for p, v in props.items(): if not self.user_set(k=k, u=ii, p=p, v=v): return False return True raise MethodNotFound
def set_prop(self, prop, value=None, save=False): with key_lock: if not self.dynamic or self.master: raise FunctionFailed( 'Master and static keys can not be changed') if prop == 'key': if value is None or value == '' or value.find( ':') != -1 or value.find('|') != -1: return False if self.key != value: if value in keys: raise ResourceAlreadyExists('API key') regenerate_key(self.key_id, k=value, save=False) self.set_modified(save) return True elif prop == 'dynamic': return False elif prop == 'sysfunc': val = val_to_boolean(value) if val is None: return False if self.sysfunc != val: self.sysfunc = val self.set_modified(save) return True elif prop == 'items': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.item_ids != val: self.item_ids = val self.set_modified(save) return True elif prop == 'groups': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.groups != val: self.groups = val self.set_modified(save) return True elif prop == 'items_ro': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.item_ids_ro != val: self.item_ids_ro = val self.set_modified(save) return True elif prop == 'groups_ro': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.groups_ro != val: self.groups_ro = val self.set_modified(save) return True elif prop == 'items_deny': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.item_ids_deny != val: self.item_ids_deny = val self.set_modified(save) return True elif prop == 'groups_deny': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.groups_deny != val: self.groups_deny = val self.set_modified(save) return True elif prop == 'allow': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] for v in val: if v not in all_allows: return False if self.allow != val: self.allow = val self.set_modified(save) return True elif prop == 'hosts_allow': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = ['0.0.0.0/0'] val = [IPNetwork(h) for h in val] if self.hosts_allow != val: self.hosts_allow = val self.set_modified(save) return True elif prop == 'hosts_assign': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] val = [IPNetwork(h) for h in val] if self.hosts_assign != val: self.hosts_assign = val self.set_modified(save) return True elif prop == 'pvt': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.pvt_files != val: self.pvt_files = val self.set_modified(save) return True elif prop == 'rpvt': if isinstance(value, list): val = value else: if value: val = value.split(',') else: val = [] if self.rpvt_uris != val: self.rpvt_uris = val self.set_modified(save) return True elif prop == 'cdata': val = [] if value is None else value if isinstance(val, str): val = val.split(',') res = [] for v in val: if v not in res: res.append(str(v)) if self.cdata != res: self.cdata = res self.set_modified(save) return True raise ResourceNotFound('property ' + prop)
def __init__(self, **kwargs): self.bose = val_to_boolean(self.lpi_cfg.get('bose')) logic = self.lpi_cfg.get('logic') if logic and logic not in ['default', 'rdc']: raise Exception('logic not supported: {}'.format(logic)) self.logic_rdc = logic == 'rdc'
def set_prop(self, prop, val=None, save=False): if prop == 'action_exec': if self.action_exec != val: if val and val[0] == '|': d = eva.uc.driverapi.get_driver(val[1:]) if not d: logging.error( 'Can not set ' + \ '%s.action_exec = %s, no such driver' % (self.oid, val)) return False self.action_exec = val self.log_set(prop, val) self.set_modified(save) return True elif prop == 'action_driver_config': if val is None: self.action_driver_config = None self.log_set(prop, None) self.set_modified(save) return True else: try: v = dict_from_str(val) except: eva.core.log_traceback() return False self.action_driver_config = v self.log_set(prop, 'dict') self.set_modified(save) return True elif prop == 'modbus_status': if self.modbus_status == val: return True if val is None: self.unregister_modbus_status_updates() self.modbus_status = None else: if val[0] not in ['h', 'c']: return False try: addr = safe_int(val[1:]) if addr > eva.uc.modbus.slave_reg_max or addr < 0: return False except: return False self.unregister_modbus_status_updates() self.modbus_status = val self.modbus_update_status(addr, eva.uc.modbus.get_data(addr, val[0])) self.register_modbus_status_updates() self.log_set('modbus_status', val) self.set_modified(save) return True elif prop == 'action_always_exec': v = val_to_boolean(val) if v is not None: if self.action_always_exec != v: self.action_always_exec = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'update_exec_after_action': v = val_to_boolean(val) if v is not None: if self.update_exec_after_action != v: self.update_exec_after_action = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'update_state_after_action': v = val_to_boolean(val) if v is not None: if self.update_state_after_action != v: self.update_state_after_action = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'update_if_action': v = val_to_boolean(val) if v is not None: if self.update_if_action != v: self.update_if_action = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'auto_off': if val is None: auto_off = 0 else: try: auto_off = float(val) except: return False if auto_off < 0: return False if self.auto_off != auto_off: self.auto_off = auto_off self.log_set(prop, auto_off) self.set_modified(save) if self.auto_off == 0: self.stop_auto_processor() else: self.start_auto_processor() return True elif prop == 'status_labels' and isinstance(val, dict): self.status_labels = val self.log_set(prop, 'dict') self.set_modified(save) self.ieid = eva.core.generate_ieid() return True elif prop[:7] == 'status:': try: s = int(prop.split(':')[1]) except: return False s = str(s) if s == '0' and (val is None or val == ''): if self.status_labels['0'] != status_label_off: self.status_labels['0'] = status_label_off self.log_set('status_labels[0]', status_label_off) self.set_modified(save) self.ieid = eva.core.generate_ieid() elif s == '1' and (val is None or val == ''): if self.status_labels['1'] != status_label_on: self.status_labels['1'] = status_label_on self.log_set('status_labels[1]', status_label_on) self.set_modified(save) self.ieid = eva.core.generate_ieid() elif val is not None and val != '': if not s in self.status_labels or self.status_labels[s] != val: self.status_labels[s] = val self.log_set('status_labels[' + s + ']', val) self.set_modified(save) self.ieid = eva.core.generate_ieid() else: if not s in self.status_labels: return False del self.status_labels[s] self.set_modified(save) self.ieid = eva.core.generate_ieid() return True else: return super().set_prop(prop, val, save)
def set_prop(self, prop, val=None, save=False): if prop == 'maintenance_duration': if val: try: v = float(val) if v < 0: raise Exception except: return False else: v = 0 if self.maintenance_duration != v: self.maintenance_duration = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'update_exec': if self.update_exec != val: if val and val[0] == '|': d = eva.uc.driverapi.get_driver(val[1:]) if not d: logging.error( 'Can not set ' + \ '%s.update_exec = %s, no such driver' % (self.oid, val)) return False if not val: self.unregister_driver_updates() self.update_exec = val self.log_set(prop, val) self.set_modified(save) self.register_driver_updates() return True elif prop == 'update_driver_config': if val is None: self.update_driver_config = None self.log_set(prop, None) self.set_modified(save) return True else: try: v = dict_from_str(val) except: eva.core.log_traceback() return False self.update_driver_config = v self.log_set(prop, 'dict') self.set_modified(save) return True elif prop == 'modbus_value': if self.modbus_value == val: return True if val is None: self.unregister_modbus_value_updates() self.modbus_value = None else: reg, addr, multiplier, signed = format_modbus_value(val) if reg is None or addr is None or multiplier is None: return False self.unregister_modbus_value_updates() self.modbus_value = val self.modbus_value_reg = reg self.modbus_value_addr = addr self.modbus_value_multiplier = multiplier self.modbus_value_signed = signed self.modbus_update_value(addr, eva.uc.modbus.get_data(addr, reg)) self.register_modbus_value_updates() self.log_set('modbus_value', val) self.set_modified(save) return True elif prop == 'snmp_trap': if val is None: self.snmp_trap = None self.unsubscribe_snmp_traps() self.log_set(prop, None) self.set_modified(save) return True elif isinstance(val, dict): self.snmp_trap = val self.subscribe_snmp_traps() self.log_set('snmp_trap', 'dict') self.set_modified(save) return True return False elif prop == 'snmp_trap.ident_vars': if val is None: if self.snmp_trap and 'ident_vars' in self.snmp_trap: del self.snmp_trap['ident_vars'] if not self.snmp_trap: self.unsubscribe_snmp_traps() self.log_set('snmp_trap.ident_vars', None) self.set_modified(save) return True else: ivars = {} try: for x in val.split(','): k, v = x.split('=') ivars[k] = v except: return False if not self.snmp_trap: self.snmp_trap = {} self.snmp_trap['ident_vars'] = ivars self.subscribe_snmp_traps() self.log_set('snmp_trap.ident_vars', val) self.set_modified(save) return True elif prop == 'snmp_trap.set_down': if val is None: if self.snmp_trap and 'set_down' in self.snmp_trap: del self.snmp_trap['set_down'] if not self.snmp_trap: self.unsubscribe_snmp_traps() self.log_set('snmp_trap.set_down', None) self.set_modified(save) return True else: ivars = {} try: for x in val.split(','): k, v = x.split('=') ivars[k] = v except: return False if not self.snmp_trap: self.snmp_trap = {} self.snmp_trap['set_down'] = ivars self.log_set('snmp_trap.set_down', val) self.subscribe_snmp_traps() self.set_modified(save) return True elif prop == 'snmp_trap.set_status': if val is None: if self.snmp_trap and 'set_status' in self.snmp_trap: del self.snmp_trap['set_status'] if not self.snmp_trap: self.unsubscribe_snmp_traps() self.log_set('snmp_trap.set_status', None) self.set_modified(save) return True else: if not self.snmp_trap: self.snmp_trap = {} self.snmp_trap['set_status'] = val self.subscribe_snmp_traps() self.log_set('snmp_trap.set_status', val) self.set_modified(save) return True elif prop == 'snmp_trap.set_value': if val is None: if self.snmp_trap and 'set_value' in self.snmp_trap: del self.snmp_trap['set_value'] if not self.snmp_trap: self.unsubscribe_snmp_traps() self.log_set('snmp_trap.set_value', None) self.set_modified(save) return True else: if not self.snmp_trap: self.snmp_trap = {} self.snmp_trap['set_value'] = val self.subscribe_snmp_traps() self.log_set('snmp_trap.set_value', val) self.set_modified(save) return True elif prop[:16] == 'snmp_trap.set_if': if val is None: if self.snmp_trap and 'set_if' in self.snmp_trap: del self.snmp_trap['set_if'] self.log_set('snmp_trap.set_if', None) self.set_modified(save) if not self.snmp_trap: self.unsubscribe_snmp_traps() return True try: state, iv = val.split(':') s, va = state.split(',') ivars = {} for x in iv.split(','): k, v = x.split('=') ivars[k] = v if not self.snmp_trap: self.snmp_trap = {} if not 'set_if' in self.snmp_trap: self.snmp_trap['set_if'] = [] r = {'vars': ivars} if s != 'null' and s != '': r['status'] = int(s) if va != 'null' and va != '': r['value'] = va self.log_set('snmp_trap.set_if+', val) self.snmp_trap['set_if'].append(r) except: return False self.subscribe_snmp_traps() self.set_modified(save) return True elif prop in ['value_condition']: try: d = self.parse_value_condition(val) for k, v in d.items(): try: if not self.set_prop(k, v): return False except: eva.core.log_traceback() return False return True except Exception as e: logging.error('Unable to parse condition: {}'.format(e)) eva.core.log_traceback() return False elif prop == 'value_in_range_min': if val is not None and val != '': try: v = float(val) except: v = val else: v = None if self.value_in_range_min != v: self.value_in_range_min = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'value_in_range_max': if val is not None and val != '': try: v = float(val) except: v = val else: v = None if self.value_in_range_max != v: self.value_in_range_max = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'value_in_range_min_eq': v = val_to_boolean(val) if v is not None: if self.value_in_range_min_eq != v: self.value_in_range_min_eq = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'value_in_range_max_eq': v = val_to_boolean(val) if v is not None: if self.value_in_range_max_eq != v: self.value_in_range_max_eq = v self.log_set(prop, v) self.set_modified(save) return True else: return False else: return super().set_prop(prop, val, save)
def set_prop(self, prop, val=None, save=False): if prop == 'enabled': v = val_to_boolean(val) if v is not None: if self.enabled != v: self.enabled = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'block_on_exec': v = val_to_boolean(val) if v is not None: if self.block_on_exec != v: self.block_on_exec = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop in ['c', 'cond', 'condition']: try: d = self.parse_rule_condition(val) for k, v in d.items(): try: if not self.set_prop(k, v): return False except: eva.core.log_traceback() return False return True except Exception as e: logging.error('Unable to parse condition: {}'.format(e)) eva.core.log_traceback() return False elif prop in ['o', 'oid', 'for_oid', 'for']: try: d = self.parse_rule_for_oid(val) for k, v in d.items(): try: if not self.set_prop(k, v): return False except: eva.core.log_traceback() return False return True except Exception as e: logging.error('Unable to parse for_oid: {}'.format(e)) eva.core.log_traceback() return False elif prop == 'for_expire': if not self.in_range_max_eq or \ self.in_range_min_eq or \ self.in_range_min is not None or \ self.in_range_max != -1 or \ self.for_prop != 'status' or \ not isinstance(self.in_range_max, float): self.in_range_min_eq = False self.in_range_max_eq = True self.in_range_min = None self.in_range_max = -1.0 self.for_prop = 'status' self.log_set(prop, val) self.set_modified(save) return True elif prop == 'for_set': if not self.in_range_max_eq or \ not self.in_range_min_eq or \ self.in_range_min != 1 or \ self.in_range_max != 1 or \ self.for_prop != 'status' or \ not isinstance(self.in_range_min, float) or \ not isinstance(self.in_range_max, float): self.in_range_min_eq = True self.in_range_max_eq = True self.in_range_min = 1.0 self.in_range_max = 1.0 self.for_prop = 'status' self.log_set(prop, val) self.set_modified(save) return True elif prop == 'priority': try: v = int(val) if v <= 0: return False except: return False if self.priority != v: self.priority = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'for_item_type': if val is not None: if val == 'U': v = 'unit' elif val == 'S': v = 'sensor' elif val == 'LV': v = 'lvar' else: v = val if not v in ['#', 'unit', 'sensor', 'lvar']: return False else: v = None if self.for_item_type != v: self.for_item_type = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'for_item_id': if self.for_item_id != val: self.for_item_id = val self.log_set(prop, val) self.set_modified(save) return True elif prop == 'for_item_group': if self.for_item_group != val: self.for_item_group = val self.log_set(prop, val) self.set_modified(save) return True elif prop == 'for_prop': if val not in ['status', 'value', 'nstatus', 'nvalue']: return False if self.for_prop != val: self.for_prop = val self.log_set(prop, val) self.set_modified(save) return True elif prop == 'for_initial': if val is not None and \ val not in [ 'only', 'skip', 'any', 'none', 'None' ]: return False v = val if v in ['any', 'none', 'None']: v = None if self.for_initial != v: self.for_initial = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'in_range_min': if val is not None and val != '': try: v = float(val) except: if self.for_prop == 'status': return False v = val else: v = None if self.in_range_min != v: self.in_range_min = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'in_range_max': if val is not None and val != '': try: v = float(val) except: if self.for_prop == 'status': return False v = val else: v = None if self.in_range_max != v: self.in_range_max = v self.log_set(prop, v) self.set_modified(save) return True elif prop == 'in_range_min_eq': v = val_to_boolean(val) if v is not None: if self.in_range_min_eq != v: self.in_range_min_eq = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'in_range_max_eq': v = val_to_boolean(val) if v is not None: if self.in_range_max_eq != v: self.in_range_max_eq = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'for_prop_bit': try: if val is None or val == '': v = None else: v = int(val) if v < 0: raise ValueError('bit number can not be negative') if self.for_prop_bit != v: self.for_prop_bit = v self.log_set(prop, v) self.set_modified(save) return True except: eva.core.log_traceback() return False elif prop == 'macro': if self.macro != val: self.macro = val self.log_set(prop, val) self.set_modified(save) return True elif prop == 'macro_args': if val is not None: if isinstance(val, list): v = val elif isinstance(val, tuple): v = list(val) else: try: v = shlex.split(val) except: v = val.split(' ') else: v = [] self.macro_args = v self.log_set(prop, val) self.set_modified(save) return True elif prop == 'macro_kwargs': if val is None: self.macro_kwargs = {} else: try: self.macro_kwargs = dict_from_str(val) except: return False self.log_set(prop, val) self.set_modified(save) return True elif prop == 'break_after_exec': v = val_to_boolean(val) if v is not None: if self.break_after_exec != v: self.break_after_exec = v self.log_set(prop, v) self.set_modified(save) return True else: return False elif prop == 'chillout_time': try: v = float(val) except: return False if self.chillout_time != v: self.chillout_time = v self.log_set(prop, v) self.set_modified(save) return True return super().set_prop(prop, val, save)
def set(self, port=None, data=None, cfg=None, timeout=0): value = data[1] if isinstance(data, tuple) else data try: modbus_port = modbus.get_port(self.modbus_port, timeout) except Exception as e: self.log_error(e) log_traceback() return None try: if port[0] in ['c', 'd']: modbus.write_bool(modbus_port, port, [value], unit=self.unit_id) else: data_type = cfg.get('type', 'u16') if data_type.startswith('v'): import math try: size = math.ceil(int(data_type[1:]) / 2) except Exception as e: self.log_error(f'invalid size: {e}') log_traceback() return None val = value[:size * 2] if len(val) % 4: val += '00' val = [int(val[i:i + 4], 16) for i in range(0, len(val), 4)] modbus.write_u16(modbus_port, port, val, unit=self.unit_id) return True try: fn_set = self._setter_functions[data_type] value = float(value) if data_type == 'f32' else int(value) except KeyError: self.log_error(f'Invalid register data type: {data_type}') raise if '/' in port: try: fn_get = self._getter_functions[data_type] value = float(value) if data_type == 'f32' else int( value) except KeyError: self.log_error( f'Invalid register data type: {data_type}') raise reg, offset = port.split('/', 1) offset = int(offset) with self.bitlock: try: b = self.cache[reg] except KeyError: b = fn_get(modbus_port, reg, unit=self.unit_id)[0] self.cache[reg] = b if val_to_boolean(value): b = b | 1 << offset else: if b >> offset & 1: b = b ^ 1 << offset fn_set(modbus_port, reg, [b], unit=self.unit_id) try: del self.cache[reg] except: pass else: value = transform_value(value, multiply=cfg.get('divide'), divide=cfg.get('multiply')) if data_type != 'f32': value = int(value) fn_set(modbus_port, port, [value], unit=self.unit_id) return True except: log_traceback() return False finally: modbus_port.release()
def set_prop(self, prop, val=None, save=False): if prop == 'macro': if self.cycle_enabled: return False if val is None: if self.macro is not None: self.macro = val self.log_set(prop, val) self.set_modified(save) return True macro = eva.lm.controller.get_macro(val, pfm=True) if macro: if not self.macro or self.macro.oid != macro.oid: self.macro = macro self.log_set(prop, val) self.set_modified(save) return True else: return False elif prop == 'macro_args': if val is not None: if isinstance(val, list): v = val else: try: v = shlex.split(val) except: v = val.split(' ') else: v = [] self.macro_args = v self.log_set(prop, val) self.set_modified(save) return True elif prop == 'macro_kwargs': if val is None: self.macro_kwargs = {} else: self.macro_kwargs = dict_from_str(val) self.log_set(prop, val) self.set_modified(save) return True elif prop == 'on_error': if val is None: if self.on_error is not None: self.on_error = val self.log_set(prop, val) self.set_modified(save) return True macro = eva.lm.controller.get_macro(val, pfm=True) if macro: if not self.on_error or self.on_error.oid != macro.oid: self.on_error = macro self.log_set(prop, val) self.set_modified(save) return True else: return False elif prop == 'interval': if self.cycle_enabled: return False try: interval = float(val) except: return False if interval > 0: if self.interval != interval: self.interval = interval self.log_set(prop, val) self.set_modified(save) return True else: return False elif prop == 'ict': try: ict = int(val) except: return False if ict > 0: if self.ict != ict: self.ict = ict self.log_set(prop, val) self.set_modified(save) return True else: return False elif prop == 'autostart': try: autostart = val_to_boolean(val) if autostart is None: raise ('Invalid val') except: return False if self.autostart != autostart: self.autostart = autostart self.log_set(prop, val) self.set_modified(save) return True else: return super().set_prop(prop, val, save)
def do_state(self, _uuid, cfg, timeout, tki, state_in): # we don't handle events if state_in: return self.state_result_error(_uuid) if cfg is None or cfg.get(self.io_label) is None: return self.state_result_error(_uuid) phi_cfg = self.prepare_phi_cfg(cfg) if self.phi._is_required.aao_get: _state_in = self.phi.get(cfg=phi_cfg, timeout=timeouter.get()) if not _state_in: return self.state_result_error(_uuid) else: _state_in = {} skip_err = val_to_boolean(cfg.get('skip_err')) if \ cfg.get('skip_err') is not None else self.skip_err gpf = cfg.get('gpf') if \ cfg.get('gpf') is not None else self.gpf max_diff = cfg.get('max_diff') if \ cfg.get('max_diff') is not None else self.max_diff try: max_diff = float(max_diff) except: max_diff = self.max_diff port = cfg.get(self.io_label) if not isinstance(port, list): _port = [port] else: _port = port multi = False for p in _port: if isinstance(p, list): multi = True break else: _port = [_port] if multi: st = [] else: st = None for pi in _port: if isinstance(pi, list): pp = pi else: pp = [pi] st_arr = [] st_ports = [] _status = 1 for p in pp: if _state_in and str(p) in _state_in: value = _state_in.get(str(p)) else: value = self.phi.get(str(p), phi_cfg, timeout=timeouter.get()) try: value = float(value) except: value = None if value is None: if not skip_err: _status = -1 break else: self.log_error('%s %s failed to get value' % (self.io_label, p)) else: st_arr.append(value) st_ports.append(str(p)) if max_diff and _status != -1 and len(st_arr) > 1: _st_ports = st_ports.copy() while True: diver = False for i in range(0, len(st_arr)): _s = st_arr.copy() del _s[i] _avg = sum(_s) / float(len(_s)) if abs(st_arr[i] - _avg) > max_diff: if len(st_arr) == 2: self.log_error( 'one %s of %s failed' % (self.io_label, ', '.join(_st_ports)) + \ ' - value is too different') if multi: _status = -1 break else: return self.state_result_error(_uuid) else: diver = True break if diver and _status != -1: diffs = [] for i in range(0, len(st_arr)): diff = 0 for i2 in range(0, len(st_arr)): if i != i2: diff += abs(st_arr[i2] - st_arr[i]) diffs.append(diff) bi = diffs.index(max(diffs)) self.log_error('%s %s seems to be failed' % (self.io_label, st_ports[bi]) + ' - value is too different') del st_arr[bi] del st_ports[bi] else: break if _status == -1 or not st_arr: if multi: st.append((-1, None)) continue else: return self.state_result_error(_uuid) if gpf == 'first': value = st_arr[0] elif gpf == 'max': value = max(st_arr) elif gpf == 'min': value = min(st_arr) else: value = sum(st_arr) / float(len(st_arr)) if multi: st.append((1, str(value))) else: st = str(value) if multi: self.set_result(_uuid, st) else: self.set_result(_uuid, (1, st)) return