def get_data(self):
if len(self.user) != 0:
ups_client = PyNUTClient(host=self.server, port=self.port, login=self.user, password=self.password)
ups_data = ups_client.list_vars(self.upsname)
else:
# Using Python 3.4 here will result in a TypeError: unsupported operand type(s) for %: 'bytes' when passing self.server, self.port
# IMPORTANT - Please use at least Python3.6
ups_client = PyNUTClient(host=self.server, port=self.port)
ups_data = ups_client.list_vars(self.upsname)
if ups_data:
self.send_log('Successfully connected to NUT Server', "info")
return ups_data
def setUp(self):
self.client = PyNUTClient(connect=False, debug=True)
self.client._srv_handler = MockServer(broken=False)
self.broken_client = PyNUTClient(connect=False, debug=True)
self.broken_client._srv_handler = MockServer(broken=True)
self.not_ok_client = PyNUTClient(connect=False, debug=True)
self.not_ok_client._srv_handler = MockServer(ok=False, broken=False)
self.valid = "test"
self.invalid = "does_not_exist"
self.valid_ups_name = "Test UPS 1"
self.valid_desc = self.valid_ups_name
self.valid_value = '100'
self.valid_command_desc = self.valid_desc
telnetlib.Telnet = Mock()
def main():
if verbose:
print("INFLUXDB_PORT: ", influx_port)
print("INFLUXDB_HOST: ", influx_host)
print("INFLUXDB_DATABASE: ", influx_dbname)
print("INFLUXDB_USER: "******"INFLUXDB_PASSWORD: "******"NUT_HOST: ", nut_host)
print("NUT_PORT: ", nut_port)
print("NUT_USER: "******"NUT_PASS: "******"UPS_NAME", ups_names)
print("INTERVAL: ", interval)
print("VERBOSE: ", verbose)
print("Connecting to InfluxDB host:{}, DB:{}".format(
influx_host, influx_dbname))
influx_client = InfluxDBClient(influx_host, influx_port, influx_username,
influx_password, influx_dbname)
influx_client.create_database(influx_dbname)
print("Connected successfully to InfluxDB")
print("Connecting to NUT host {}:{}".format(nut_host, nut_port))
nut_client = PyNUTClient(host=nut_host,
port=nut_port,
login=nut_username,
password=nut_password,
debug=verbose)
print("Connected successfully to NUT")
# Main infinite loop: Get the data from NUT every interval and send it to InfluxDB.
while True:
for ups_name in ups_names:
# Query NUT for data about this UPS
ups_data = nut_client.list_vars(ups_name)
# Convert NUT data format to InfluxDB format
json_body = construct_object(ups_data)
if verbose:
print(json_body)
# Write the latest data to InfluxDB
write_result = influx_client.write_points(json_body)
if verbose:
print(write_result)
time.sleep(interval)
def test_connect_credentials(self):
try:
PyNUTClient(login=self.valid, password=self.valid, debug=True)
except TypeError:
pass
except PyNUTError:
pass
except Exception:
assert (False)
def test_connect_credentials_username_ok(self):
try:
telnetlib.Telnet = MockServer
PyNUTClient(login=self.valid, password=self.valid, debug=True)
except TypeError:
pass
except PyNUTError:
pass
except Exception:
assert (False)
def _get_raw_state_nut(self):
self._logger.debug("Updating UPS state from NUT")
try:
client = PyNUTClient()
ups = list(client.list_ups().keys())[0]
data = client.list_vars(ups)
return data
except PyNUTError as e:
self._logger.warning("Error updating UPS state from NUT: " + repr(e))
return None
def __init__(self):
print(f'Connecting to NUT host {ups_name}@{host}:{port}...')
self.ups_client = PyNUTClient(host=host,
port=port,
login=username,
password=password,
debug=verbose)
self.ups_name = ups_name
if self.ups_client:
print(f'Connected successfully to NUT {host}:{port}')
def get_metrics(ups_name, ups_host, ups_port):
client = PyNUTClient(ups_host, ups_port)
client_vars = client.list_vars(ups_name)
metrics = {}
for var in client_vars:
try:
float(client_vars.get(var))
desc = client.var_description(ups_name, var)
var_split = var.split(".")
if var_split[0] != "ups":
var_split.insert(0, "ups")
name = "_".join(var_split)
metrics.update({var: Gauge(name, desc)})
except Exception as e:
logger.debug(f"Exception: {e}!")
return metrics
def nutPullData(host, port, username, password):
try:
nut = PyNUTClient(host=host,port=port,login=username,password=password)
except:
print("there was an error connecting to host:"+host)
return False
ups_data = []
for ups_name,_description in nut.list_ups().items():
ups_vars = nut.list_vars(ups_name)
ups_vars['name'] = ups_name
if ups_vars['device.type'] != 'ups':
continue
for element in ups_vars:
if ups_vars[element].replace('.','',1).isdigit():
ups_vars[element] = float(ups_vars[element])
ups_data.append(ups_vars)
return ups_data
def readupsvar():
print('\nreadupsvar()')
global ups_status
global battery_charge
global battery_runtime
global output_voltage
try:
# connect to UPS service
# ups = PyNUT.PyNUTClient( host='localhost', login='******', password='******' )
ups = PyNUTClient()
# read all info from ups
# UPSvars = ups.GetUPSVars( ups='eaton800' )
UPSvars = ups.list_vars("eaton800")
# convert it in JSON format (easier to parse with JSON module)
UPSVarsJSON = json.dumps(UPSvars)
# parse JSON info
Parsed_UPSVarsJSON = json.loads(UPSVarsJSON)
# store infos in global variables
battery_charge = int(Parsed_UPSVarsJSON['battery.charge'])
battery_runtime = int(Parsed_UPSVarsJSON['battery.runtime'])
ups_status = Parsed_UPSVarsJSON['ups.status']
output_voltage = float(Parsed_UPSVarsJSON['output.voltage'])
# print debug and log message
logmessage = " ups status is " + ups_status + " \n battery charge is " + str(
battery_charge) + " % \n output voltage is " + str(
output_voltage) + "V \n remaining is " + str(
battery_runtime) + " minutes"
print(logmessage)
except:
logmessage = " Error while reading or parsing UPS Variables"
print(logmessage)
if args['debug'] == None:
debug_level = 3
else:
debug_level = args['debug']
settings = Settings(args["conf"], None, log)
hmqtt = Homie_MQTT(settings)
settings.print()
# Now we loop forever
unresp = 0
while True:
# get the ups data
status = {}
try:
with PyNUTClient() as s:
status = s.list_vars(settings.nut_ups)
except:
pass
# did we get good values?
if 'ups.status' not in status or 'battery.charge' not in status or 'battery.runtime' not in status:
unresp += 1
if unresp > 5:
# Send warning to MQTT topic?
hmqtt.send_pwr_state(status, True)
log("Can't Reach UPS")
unresp = 0
time.sleep(60)
continue
start_http_server(9120)
logger.info("Metrics server started")
# Allow loop to be killed gracefully
killer = GracefulKiller()
# Check UPS metrics
for loop_counter in itertools.count():
if killer.kill_now:
logger.debug("Recieved SIGINT or SIGTERM")
break
try:
if loop_counter % lookup_rate == 0:
logger.debug("Resolving UPS IP Address...")
ups_ip = socket.gethostbyname(ups_host)
logger.debug(f"UPS IP Address is {ups_ip}")
if loop_counter % poll_rate == 0:
data = PyNUTClient(ups_ip, ups_port).list_vars(ups_name)
update_metrics(data, basic_metrics)
update_label_metrics(data)
logger.debug(f"Checked {ups_fullname}")
except Exception as e:
logger.error(f"Failed to connect to {ups_fullname}!")
logger.debug(f"Exception: {e}!")
clear_metrics(basic_metrics)
clear_label_metrics()
logger.debug("Reset metrics to 0 because UPS was unreachable")
time.sleep(1)
logger.info("Shutting down...")
print("N pass: "******"IP list:")
print(json.dumps(nut_ip_list, indent=4))
print("Host list:")
print(json.dumps(nut_host_list, indent=4))
# loop over unique names (allows non unique ip for test)
for host in nut_host_list:
position = nut_host_list.index(host)
ipaddress = nut_ip_list[position]
print("\nDO NUT: " + nut_upsname + "@" + ipaddress + " > " + host)
# setup NUT
ups_client = PyNUTClient(host=ipaddress,
port=nut_port,
login=nut_username,
password=nut_password,
debug=nut_debug)
if ups_client and debug:
print(" NUT: online")
# push to Influx
while True:
try:
ups_data = ups_client.list_vars(nut_upsname)
if debug:
print("RAW: " + nut_upsname + " @ " + ipaddress)
print(json.dumps(ups_data, indent=4))
except:
tb = traceback.format_exc()
if debug:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# This source code is provided for testing/debuging purpose ;)
from nut2 import PyNUTClient
import sys
if __name__ == "__main__":
print("PyNUTClient test...")
nut = PyNUTClient(debug=True)
#nut = PyNUTClient( login="******", password="******", debug=True )
print(80 * "-" + "\nTesting 'GetUPSList' :")
result = nut.GetUPSList()
print("\033[01;33m%s\033[0m\n" % result)
print(80 * "-" + "\nTesting 'GetUPSVars' :")
result = nut.GetUPSVars("dummy")
print("\033[01;33m%s\033[0m\n" % result)
print(80 * "-" + "\nTesting 'GetUPSCommands' :")
result = nut.GetUPSCommands("dummy")
print("\033[01;33m%s\033[0m\n" % result)
print(80 * "-" + "\nTesting 'GetRWVars' :")
result = nut.GetRWVars("dummy")
print("\033[01;33m%s\033[0m\n" % result)
print(80 * "-" + "\nTesting 'RunUPSCommand' (Test front panel) :")
#[ -e /var/run/nut ] || ln -s /dev/shm/nut /var/run
# Issue #15 - change pid warning message from "No such file" to "Ignoring"
#os.system('echo 0 > /var/run/nut/upsd.pid && chown $USER.$GROUP /var/run/nut/upsd.pid')
# os.system('echo 0 > /var/run/nut/upsd.pid')
# os.system('echo 0 > /var/run/upsmon.pid')
# os.system('chmod -R 777 /var/run')
# os.system('upsdrvctl -u root start')
# os.system('upsd')
# os.system('upsmon -D &')
# time.sleep(10)
while 1:
client = PyNUTClient()
fields = {}
for var in client.list_vars(ups_name):
value = client.get_var(ups_name, var)
try:
fields[var] = float(value)
except:
fields[var] = value
measurement = [{'measurement': 'ups', 'fields': fields}]
print(measurement)
influx_client = InfluxDBClient(influx_host,
influx_port,
def test_supports_context_manager(self):
try:
with PyNUTClient(connect=False) as client:
pass
except AttributeError:
assert (False)
def test_init_with_args(self):
PyNUTClient(connect=False,
login='******',
password='******',
host='test',
port=1)
def collect(self):
client = PyNUTClient(host=self._host, port=self._nut_port)
client_vars = client.list_vars(self._ups_name)
nut_server = "{}:{}".format(self._host, self._nut_port)
info = GaugeMetricFamily(
"nut_device_info",
"information about the UPS",
labels=["manufacturer", "model", "serial", "nut_server", "ups"],
)
info.add_metric(
# APC UPSes seem to add whitespace at the end of the serial number
[
client_vars["device.mfr"],
client_vars["device.model"],
client_vars["device.serial"].strip(),
nut_server,
self._ups_name,
],
1,
)
yield info
ups_status = GaugeMetricFamily("nut_ups_status",
"UPS status",
labels=["status", "nut_server", "ups"])
ups_status.add_metric(
[client_vars["ups.status"], nut_server, self._ups_name], 1.0)
yield ups_status
if "ups.beeper.status" in client_vars:
ups_beeper_status = GaugeMetricFamily(
"nut_ups_beeper_status",
"UPS beeper status",
labels=["status", "nut_server", "ups"],
)
ups_beeper_status.add_metric(
[client_vars["ups.beeper.status"], nut_server, self._ups_name],
1.0)
yield ups_beeper_status
if "battery.charger.status" in client_vars:
battery_charger_status = GaugeMetricFamily(
"nut_battery_charger_status",
"Status of the battery charger",
labels=["status", "nut_server", "ups"],
)
battery_charger_status.add_metric([
client_vars["battery.charger.status"], nut_server,
self._ups_name
], 1.0)
yield battery_charger_status
for var in client_vars:
if var in METRICS:
formatted_name = var.replace(".", "_")
if METRICS[var]["unit"]:
formatted_name = "_".join(
("nut", formatted_name, METRICS[var]["unit"]))
else:
formatted_name = "_".join(("nut", formatted_name))
metric = GaugeMetricFamily(formatted_name,
METRICS[var]["help"],
labels=["nut_server", "ups"])
metric.add_metric([nut_server, self._ups_name],
client_vars[var])
yield metric
def test_connect_broken(self):
telnetlib.Telnet = MockServer
client = PyNUTClient(login=self.valid,
password=self.valid,
connect=False)
self.assertRaises(PyNUTError, client._connect)
def test_connect(self):
try:
PyNUTClient()
except Exception:
assert (False)
def __init__(self, config=None):
self.configuration = config
self.timestamp = None
self.http = None
self.parsed_data = OrderedDict()
# self.time_zone = 'Europe/Berlin'
self.time_zone = 'UTC'
self.tz = pytz.timezone(self.time_zone)
self.nut_name = "ups"
self.nut = PyNUTClient(host=self.configuration[self.name]['IPAdresse'], debug=False, connect=False)
self.parsed_data = None
self.id_fields = {
"battery.charge": ["battery_charge", int],
# "battery.charge.low": "10",
# "battery.charge.warning": "50",
# "battery.date": "2001/09/25",
# "battery.mfr.date": "2019/04/27",
"battery.runtime": ["battery_runtime", int],
# "battery.runtime.low": "battery_runtime_low",
# "battery.type": "PbAc
"battery.voltage": ["battery_voltage", float],
# "battery.voltage.nominal": "12.0
# "device.mfr": "American Power Conversion
# "device.model": "Back-UPS XS 700U
# "device.serial": "3B1917X69838
# "device.type": "ups
# "driver.name": "usbhid-ups
# "driver.parameter.pollfreq": "30
# "driver.parameter.pollinterval": "5
# "driver.parameter.port": "auto
# "driver.version": "DSM6-2-25364-191230
# "driver.version.data": "APC HID 0.95
# "driver.version.internal": "0.38
# "input.sensitivity": "high
# "input.transfer.high": "290
# "input.transfer.low": "140
"input.voltage": ["input_voltage", float],
# "input.voltage.nominal": "230
# "ups.beeper.status": "enabled
# "ups.delay.shutdown": "20
# "ups.firmware": "924.Z3 .I
# "ups.firmware.aux": "Z3
"ups.load": ["ups_load", int],
# "ups.mfr": "American Power Conversion
# "ups.mfr.date": "2019/04/27
# "ups.model": "Back-UPS XS 700U
# "ups.productid": "0002
"ups.realpower.nominal": ["nominal_power", int],
# "ups.serial": "3B1917X69838
"ups.status": ["ups_status", str],
# "ups.test.result": "No test initiated
# "ups.timer.reboot": "0
# "ups.timer.shutdown": "-1
# "ups.vendorid": "051d
}
self.average_ignores = [
'TIMESTAMP',
'time_sec',
'ups_status',
]
if os.getenv('VERBOSE', 'false').lower() == 'true':
print("INFLUXDB_DATABASE: ", dbname)
print("INFLUXDB_USER: "******"INFLUXDB_PASSWORD: "******"INFLUXDB_PORT: ", port)
print("INFLUXDB_HOST: ", host)
print("NUT_USER: "******"NUT_PASS: "******"UPS_NAME", ups_name)
print("INTERVAL: ", interval)
print("VERBOSE: ", verbose)
print("Connecting to NUT host {}:{}".format(nut_host, nut_port))
ups_client = PyNUTClient(host=nut_host,
port=nut_port,
login=nut_username,
password=nut_password,
debug=(verbose == 'true'))
if ups_client:
print("Connected successfully to NUT")
def convert_to_type(s):
""" A function to convert a str to either integer or float. If neither, it will return the str. """
try:
float_var = float(s)
return float_var
except ValueError:
return s
def test_connect_debug(self):
try:
PyNUTClient(debug=True)
except Exception:
assert (False)
