def get_ports(self):
ports = {}
# get ports
for p in self.snmp_get(oid='1.3.6.1.2.1.2.2.1.1',
timeout=get_timeout(),
walk=True):
port_number = int(p[1])
ports[port_number] = {'port': str(port_number)}
# get port names
for p in self.snmp_get(oid='1.3.6.1.2.1.2.2.1.2',
timeout=get_timeout(),
walk=True):
port_number = int(str(p[0].getOid()).rsplit('.', 1)[1])
if port_number in ports:
ports[port_number]['name'] = str(p[1])
# get port speeds
for p in self.snmp_get(oid='1.3.6.1.2.1.2.2.1.5',
timeout=get_timeout(),
walk=True):
port_number = int(str(p[0].getOid()).rsplit('.', 1)[1])
if port_number in ports:
ports[port_number]['description'] = 'speed: {}'.format(p[1])
result = []
for p in sorted(ports):
for x in ['in', 'out']:
port = ports[p].copy()
port['port'] = '{}_{}'.format(x, port['port'])
port['name'] = '{} {}put'.format(port['name'], x)
result.append(port)
return result
def test(self, cmd=None):
if cmd == 'module':
return 'default' if not netsnmp else 'netsnmp'
elif cmd == 'info':
name = snmp.get('.1.3.6.1.4.1.3854.1.1.8.0',
self.snmp_host,
self.snmp_port,
self.community,
timeout=get_timeout(),
snmp_ver=1)
if not name: return 'FAILED'
vendor = snmp.get('.1.3.6.1.4.1.3854.1.1.6.0',
self.snmp_host,
self.snmp_port,
self.community,
timeout=get_timeout(),
snmp_ver=1)
if not vendor: return 'FAILED'
return '%s %s' % (vendor.strip(), name.strip())
if cmd == 'self':
t = self.get('t', timeout=get_timeout())
h = self.get('h', timeout=get_timeout())
return 'OK' if t and h else 'FAILED'
return {
'info': 'returns relay ip module name and version',
'module': 'current SNMP module'
}
def _perform_update(self):
self.log_debug('performing update')
to.init(timeout=get_timeout())
state = self.get(timeout=get_timeout())
if not state:
return
if self._last_update_state:
stu = {}
for x, v in state.items():
if v != self._last_update_state.get(x):
stu[x] = v
else:
if self.__benchmark:
self.__last_update_reset = time()
self.log_warning('benchmark mode')
stu = state
if self.__benchmark:
self.__update_count += 1
self._last_update_state = state.copy()
if stu:
handle_phi_event(self, 'scheduler', stu)
if self.__benchmark and self.__update_count > 1 / self._update_interval:
self.log_warning('update benchmark: {}/s'.format(
round(self.__update_count /
(time() - self.__last_update_reset))))
self.__update_count = 0
self.__last_update_reset = time()
def test(self, cmd=None):
if cmd == 'self':
try:
identity = self.proxy.operate('list_identity')
return 'OK'
except:
log_traceback()
return 'FAILED'
elif cmd == 'info':
identity = self.proxy.operate('list_identity')
return {
'product_name': str(identity.get('product_name')),
'serial_number': str(identity.get('serial_number'))
}
elif cmd == 'get':
if self.tags:
return self.get(timeout=get_timeout())
else:
return 'tag list not specified'
elif cmd == 'help':
return {
'info': 'get equpment identity',
'get': 'get all tags',
'<TAG>': 'get tag value'
}
else:
return self.get(port=cmd, timeout=get_timeout())
def test(self, cmd=None):
if cmd == 'self':
return 'OK' if self.get(timeout=get_timeout()) else 'FAILED'
if cmd == 'get':
return self.get(timeout=get_timeout())
return {
'get': 'get provider data',
}
def test(self, cmd=None):
if cmd == 'self':
result = self.get(timeout=get_timeout())
return 'OK' if result else 'FAILED'
elif cmd == 'get':
return self.get(timeout=get_timeout())
else:
return {'get': 'get AOUT state'}
def process_snmp_trap(self, host, data):
if host != self.snmp_host: return
if data.get('1.3.6.1.4.1.3854.1.7.4.0') != str(self.sensor_port - 1):
return
d = data.get('1.3.6.1.4.1.3854.1.7.1.0')
if d == '7':
handle_phi_event(self, ['t', 'h'], {'t': False, 'h': False})
elif d == '2':
t = self.get('t', timeout=get_timeout())
h = self.get('h', timeout=get_timeout())
handle_phi_event(self, ['t', 'h'], {'t': t, 'h': h})
return
def test(self, cmd=None):
if cmd == 'module':
return 'default' if not netsnmp else 'netsnmp'
if cmd == 'self' and self.snmp_host is None: return 'OK'
if cmd == 'info' or cmd == 'self':
if netsnmp:
try:
sess = netsnmp.Session(
Version=2,
DestHost=self.snmp_host,
RemotePort=self.snmp_port,
Community=self.snmp_read_community,
Timeout=int(get_timeout() * 1000000),
Retries=self.snmp_tries - 1)
except:
log_traceback()
sess = None
if netsnmp:
try:
name = sess.get(netsnmp.VarList(self.oid_name))[0].decode()
except:
log_traceback()
name = None
else:
name = snmp.get(
self.oid_name,
self.snmp_host,
self.snmp_port,
self.snmp_read_community,
timeout=get_timeout(),
retries=self.snmp_tries - 1)
if not name: return 'FAILED'
if name and cmd == 'self': return 'OK'
if netsnmp:
try:
version = sess.get(netsnmp.VarList(
self.oid_version))[0].decode()
except:
version = None
else:
version = snmp.get(
self.oid_version,
self.snmp_host,
self.snmp_port,
self.snmp_read_community,
timeout=get_timeout())
if not version: return 'FAILED'
return '%s %s' % (name.strip(), version.strip())
return {
'info': 'returns relay ip module name and version',
'module': 'current SNMP module'
}
def state(self, _uuid, cfg=None, timeout=None, tki=None, state_in=None):
if timeout:
_timeout = timeout
else:
_timeout = get_timeout()
if tki:
_tki = tki
else:
_tki = get_timeout() - self.default_tki_diff
if _tki < 0: _tki = 0
if not self.phi:
self.log_error('no PHI assigned')
return None
return self.do_state(_uuid, cfg, timeout, _tki, state_in)
def set_result(self, _uuid, result=None):
if not self.__results_lock.acquire(timeout=get_timeout()):
self.critical('GenericLPI::set_result locking broken')
return None
self.__results[_uuid] = result
self.__results_lock.release()
return True
def test(self, cmd=None):
if cmd == 'self':
mb = modbus.get_port(self.modbus_port)
if not mb: return 'FAILED'
mb.release()
return 'OK'
if cmd == 'info':
mb = modbus.get_port(self.modbus_port)
if not mb: return 'FAILED'
if mb.client_type in ['tcp', 'udp']:
reg = 22
else:
reg = 21
rr = mb.read_holding_registers(reg, 1, unit=self.addr)
mb.release()
if rr.isError(): return 'FAILED'
try:
return '{:.2f}'.format(float(rr.registers[0]) / 100.0)
except:
log_traceback()
return 'FAILED'
if cmd == 'get': return self.get(timeout=get_timeout() * 10)
return {
'info': 'returns relay firmware version',
'get': 'get current relay state'
}
def _append_terminate(self, _uuid):
if not self.__terminate_lock.acquire(timeout=get_timeout()):
self.critical('GenericLPI::_append_terminate locking broken')
return None
self.__terminate[_uuid] = threading.Event()
self.__terminate_lock.release()
return True
def get_result(self, _uuid):
if not self.__results_lock.acquire(timeout=get_timeout()):
self.critical('GenericLPI::get_result locking broken')
return None
result = self.__results.get(_uuid)
self.__results_lock.release()
return result
def test(self, cmd=None):
if cmd == 'get' or cmd == 'self':
result = self.get(timeout=get_timeout())
if cmd == 'self':
return 'OK' if result else 'FAILED'
return result
return {'get': 'get socket status'}
def test(self, cmd=None):
if cmd == 'self' and self.relay_host is None: return 'OK'
if cmd == 'get' or cmd == 'self':
result = self.get(timeout=get_timeout())
if cmd == 'self':
return 'OK' if result else 'FAILED'
return result if result else 'FAILED'
return {'get': 'returns current relay state'}
def test(self, cmd=None):
if cmd == 'self':
mb = modbus.get_port(self.modbus_port)
if not mb: return 'FAILED'
mb.release()
return 'OK'
if cmd == 'get': return self.get(timeout=get_timeout() * 10)
return {'get': 'get current relay state'}
def unload(self):
try:
result = requests.delete(self.api_uri, timeout=get_timeout())
if not result.ok:
raise Exception
except:
self.log_warning('unable to delete token')
log_traceback()
def exec(self, cmd=None, args=None):
try:
if cmd == 'scan':
result = requests.post('{}/lights'.format(self.api_uri),
timeout=get_timeout()).json()
return result
elif cmd == 'delete':
result = requests.delete('{}/lights/{}'.format(
self.api_uri, int(args)),
timeout=get_timeout()).json()
return result
else:
return {
'scan': 'scan for a new lights',
'delete': 'delete light'
}
except:
log_traceback()
return None
def unload(self):
try:
result = requests.delete('{}/config/whitelist/{}'.format(
self.api_uri, self.user),
timeout=get_timeout()).json()
if 'success' not in result[0]:
raise Exception
except:
self.log_warning('unable to delete user from the bridge')
log_traceback()
def _remove_terminate(self, _uuid):
if not self.__terminate_lock.acquire(timeout=get_timeout()):
self.critical('GenericLPI::_remove_terminate locking broken')
return None
try:
del (self.__terminate[_uuid])
except:
self.__terminate_lock.release()
return False
self.__terminate_lock.release()
return True
def clear_result(self, _uuid):
if not self.__results_lock.acquire(timeout=get_timeout()):
self.critical('GenericLPI::clear_result locking broken')
return None
try:
del (self.__results[_uuid])
except:
self.__results_lock.release()
return False
self.__results_lock.release()
return True
def terminate(self, _uuid):
if not self.__terminate_lock.acquire(timeout=get_timeout()):
self.critical('GenericLPI::terminate locking broken')
return None
t = self.__terminate.get(_uuid)
if not t:
self.__terminate_lock.release()
return False
t.set()
self.__terminate_lock.release()
return True
def action(self,
_uuid,
status=None,
value=None,
cfg=None,
timeout=None,
tki=None):
if timeout:
_timeout = timeout
else:
_timeout = get_timeout()
if tki:
_tki = tki
else:
_tki = get_timeout() - self.default_tki_diff
if _tki < 0: _tki = 0
if not self.phi:
self.log_error('no PHI assigned')
return None
self.prepare_action(_uuid)
return self.do_action(_uuid, status, value, cfg, timeout, tki)
def test(self, cmd=None):
if cmd in ['self', 'get']:
result = self.get(timeout=get_timeout())
if result is not None:
return 'OK' if cmd == 'self' else {
'status': result[0],
'value': result[1]
}
else:
return 'FAILED' if cmd == 'self' else None
else:
return {'get': 'get bulb status and color'}
def test(self, cmd=None):
if cmd == 'self':
try:
modbus_port = modbus.get_port(self.modbus_port, get_timeout())
return 'OK'
except Exception as e:
self.log_error(e)
log_traceback()
return 'FAILED'
finally:
modbus_port.release()
elif cmd == 'help':
return {'reg[:type]': 'get register value'}
else:
cfg = {}
tt = cmd.split(':')
try:
cfg['type'] = tt[1]
except IndexError:
pass
return self.get(tt[0], cfg=cfg, timeout=get_timeout())
def test(self, cmd=None):
if cmd in ['self', 'get']:
try:
u = self.api_uri
result = requests.get(u, timeout=get_timeout()).json()
if 'manufacturer' not in result:
raise Exception
return 'OK' if cmd == 'self' else result
except:
log_traceback()
return 'FAILED' if cmd == 'self' else None
else:
return {'get': 'get panel info'}
def test(self, cmd=None):
if cmd == 'self':
try:
identity = self.proxy.operate('list_identity')
return 'OK'
except:
log_traceback()
return 'FAILED'
elif cmd == 'info':
identity = self.proxy.operate('list_identity')
return {
'product_name': str(identity.get('product_name')),
'serial_number': str(identity.get('serial_number'))
}
elif cmd == 'get':
if self.tags:
return self.get(timeout=get_timeout())
else:
return 'tag list not specified'
elif cmd == 'help':
return {
'info': 'get equpment identity',
'get': 'get all tags',
'<TAG>': 'get/set tag opts (<TAG>=<VALUE> for set)'
}
else:
if '=' in cmd:
ops = cmd.split(',')
ports = []
data = []
for o in ops:
p, v = o.split('=', 1)
ports.append(p)
data.append(v)
return 'OK' if self.set(
port=ports, data=data, timeout=get_timeout()) else 'FAILED'
else:
return self.get(port=cmd, timeout=get_timeout())
def test(self, cmd=None):
if cmd == 'self':
try:
if os.path.isdir('/sys/bus/gpio'):
return 'OK'
else:
raise Exception('gpio bus not found')
except:
log_traceback()
return 'FAILED'
elif cmd == 'get':
return self.get(timeout=get_timeout())
else:
return {'get', 'Return current sensor state'}
def test(self, cmd=None):
if cmd == 'module':
return 'default' if not netsnmp else 'netsnmp'
elif cmd in ['self', 'info']:
o = 'iso.3.6.1.2.1.1.1.0'
if netsnmp:
try:
result = self.create_session(get_timeout()).get(
netsnmp.VarList(o))[0].decode()
except:
log_traceback()
result = None
else:
result = self.snmp_get(oid=o, timeout=get_timeout(), rf=str)
if result:
return 'OK' if cmd == 'self' else result
else:
return 'FAILED' if cmd == 'self' else None
else:
return {
'info': 'get equipment model/vendor',
'module': 'current SNMP module'
}
def test(self, cmd=None):
if cmd == 'self':
mb = modbus.get_port(self.modbus_port, get_timeout())
rr = mb.read_input_registers(30000, 1, unit=self.addr)
mb.release()
try:
if rr.isError():
raise Exception(str(rr))
if rr.registers[0] != 1:
raise Exception('status: {}'.format(rr.registers[0]))
return 'OK'
except Exception as e:
self.log_error(e)
return 'FAILED'
elif cmd == 'fwver':
mb = modbus.get_port(self.modbus_port, get_timeout())
rr = mb.read_input_registers(30001, 1, unit=self.addr)
mb.release()
if rr.isError():
self.log_error(rr)
return None
return rr.registers[0]
else:
return {'fwver': 'Get firmware version'}
