def do_action(self, _uuid, status, value, cfg, timeout, tki):
if cfg is None:
return self.action_result_error(_uuid, 1, 'no config provided')
phi_cfg = self.prepare_phi_cfg(cfg)
if status is None:
return self.action_result_error(_uuid, 1, 'no status provided')
port = cfg.get(self.io_label)
if port is None:
return self.action_result_error(
_uuid, 1, 'no ' + self.io_label + ' in config')
try:
status = int(status)
except:
return self.action_result_error(_uuid, msg='status is not integer')
# if status not in [0, 1] and not eva.benchmark.enabled:
# return self.action_result_error(
# _uuid, msg='status is not in range 0..1')
if not isinstance(port, list):
_port = [port]
else:
_port = port
if self.phi._has_feature.aao_set:
ports_to_set = []
data_to_set = []
for p in _port:
_port, invert = self.need_invert(p)
if invert:
_status = 1 - status
else:
_status = status
state = (_status,
value) if self.phi._is_required.value else _status
if self.phi._has_feature.aao_set:
ports_to_set.append(_port)
data_to_set.append(state)
else:
set_result = self.phi.set(_port,
state,
phi_cfg,
timeout=timeouter.get())
if set_result is False or set_result is None:
return self.action_result_error(_uuid,
msg='port %s set error' %
_port)
if self.phi._has_feature.aao_set:
set_result = self.phi.set(ports_to_set,
data_to_set,
timeout=timeouter.get())
if set_result is False or set_result is None:
return self.action_result_error(_uuid, msg='ports set error')
return self.action_result_ok(_uuid)
def do_state(self, _uuid, cfg, timeout, tki, state_in):
_state_in = state_in
# for events - skip update if PHI not provided any value
if _state_in:
evh = True
else:
evh = False
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 and not _state_in:
_state_in = self.phi.get(cfg=phi_cfg, timeout=timeout)
if not _state_in:
return self.state_result_error(_uuid)
port = cfg.get(self.io_label)
if not isinstance(port, list):
_port = [port]
multi = False
else:
_port = port
multi = True
st = []
for p in _port:
if _state_in:
value = _state_in.get(str(p))
else:
value = self.phi.get(str(p), phi_cfg, timeouter.get())
if value is None and evh:
if multi:
st.append(False)
continue
else:
return self.state_result_skip(_uuid)
if value is None or value is False:
if multi:
st.append((-1, None))
continue
else:
return self.state_result_error(_uuid)
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
def operate(self, fn, *args, **kwargs):
"""
call proxy function
e.g. operate('read', *args, **kwargs)
"""
for x in range(self.op_retries + 1):
if not to.has(self.timeout):
raise TimeoutError
try:
result = getattr(self, fn)(*args, **kwargs)
if isinstance(result, GeneratorType):
result = list(result)
if not result:
raise Exception
return result
except:
if not to.has(self.timeout):
raise TimeoutError
if not self._proxy_lock.acquire(timeout=to.get(check=True)):
raise TimeoutError('lock timeout')
try:
if not to.has(self.timeout):
raise TimeoutError
try:
self.close_gateway()
except:
log_traceback()
if not to.has(self.timeout):
raise TimeoutError
try:
self.open_gateway()
except:
log_traceback()
finally:
self._proxy_lock.release()
else:
raise RuntimeError(
f'Unable to communicate with EnIP ({self.host}:{self.port})')
def do_state(self, _uuid, cfg, timeout, tki, state_in):
_state_in = state_in
if _state_in:
evh = True
else:
evh = False
phi_cfg = self.prepare_phi_cfg(cfg)
if _state_in:
status = _state_in.get(list(_state_in)[0])
else:
status = self.phi.get(1, cfg=phi_cfg, timeout=timeouter.get())
if isinstance(status, dict):
status = status.get(list(status)[0])
if isinstance(status, tuple):
status, value = status
else:
value = None
if status is None and evh:
return self.state_result_skip(_uuid)
if status is None or status is False:
return self.state_result_error(_uuid)
self.set_result(_uuid, (status, value))
return
def do_action(self, _uuid, status, value, cfg, timeout, tki):
phi_cfg = self.prepare_phi_cfg(cfg)
if status is None:
return self.action_result_error(_uuid, 1, 'no status provided')
try:
status = int(status)
except:
return self.action_result_error(_uuid, msg='status is not integer')
# if status not in [0, 1]:
# return self.action_result_error(
# _uuid, msg='status is not in range 0..1')
_port = 1
if self.phi._is_required.value:
state = status, value
else:
state = status
set_result = self.phi.set(_port,
state,
phi_cfg,
timeout=timeouter.get())
if set_result is False or set_result is None:
return self.action_result_error(_uuid,
msg='port %s set error' % _port)
return self.action_result_ok(_uuid)
def do_state(self, _uuid, cfg, timeout, tki, state_in):
_state_in = state_in
if _state_in:
evh = True
else:
evh = False
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 and not _state_in:
_state_in = self.phi.get(cfg=phi_cfg, timeout=timeouter.get())
if not _state_in:
return self.state_result_error(_uuid)
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
if multi:
st = []
else:
st = None
for pi in _port:
if isinstance(pi, list):
pp = pi
else:
pp = [pi]
st_prev = None
val_prev = None
for p in pp:
_p, invert = self.need_invert(p)
if _state_in:
status = _state_in.get(str(_p))
else:
status = self.phi.get(str(_p),
phi_cfg,
timeout=timeouter.get())
if isinstance(status, tuple):
status, value = status
else:
value = None
try:
status = int(status)
except:
status = None
if status is None and evh:
if multi:
st_prev = False
break
else:
return self.state_result_skip(_uuid)
if status is None or (invert and status not in [0, 1]):
if multi:
st_prev = -1
break
else:
return self.state_result_error(_uuid)
if invert:
_status = 1 - status
else:
_status = status
if multi:
if st_prev is None:
st_prev = _status
val_prev = value
elif st_prev != _status or val_prev != value:
st_prev = -1
break
else:
if st is None:
st = (_status, value)
elif st[0] != _status or st[1] != value:
self.set_result(_uuid, (-1, None))
return
if multi:
if st_prev is False:
st.append(False)
else:
st.append((st_prev, val_prev))
self.set_result(_uuid, st)
return
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