def get_ups_stats(self): """ """ ret = False if self._ups_stats_next_run < datetime.now(): locked = self._lock.acquire(False) if locked == True: try: client = PyNUTClient(host=self.values['ip_ping_config'].data,login=self.values['username'].data, password=self.values['password'].data, port=self.values['port'].data) res = client.list_vars(self.values['upsname'].data) self._battery_charge = res['battery.charge'] self._battery_voltage = res['battery.voltage'] self._battery_runtime = res['battery.runtime'] self._battery_chemistry = res['battery.chemistry'] self._status = res['ups.status'] self.node.product_name = res['ups.model'] self.node.product_type = res['ups.serial'] self.node.product_manufacturer = res['ups.mfr'] self._ups_stats_last = True ret = True except Exception: logger.exception("[%s] - Exception catched in get_ups_stats", self.__class__.__name__) self._ups_stats_last = False finally: self._lock.release() logger.debug("And finally release the lock !!!") if self.values['ip_ping_poll'].data>0: self._ups_stats_next_run = datetime.now() + timedelta(seconds=self.values['ip_ping_poll'].data) return ret return False
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 _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 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 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 update(self): nut = PyNUTClient(host=self.host, port=self.port, login=self.login, password=self.password) # get data #TODO: add try catch on it to detect error try: data = nut.list_vars(self.upsname) except PyNUTError as err: self._logger.error(err) self.error = "Communication error with UPS" else: for name, source in self._sources.items(): key = name.replace("_", ".") if key in data: source.value = data[key] else: self._logger.debug("Missing data: %s" % key) #pprint(data) del nut #close connection
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 battery_pc_status(self): msg = BatteryStatus() msg.percent = -1 msg.plugged_in = False msg.voltage = -1 msg.current = -1 msg.temp = -1 success = False try: ups = PyNUTClient() bat = ups.list_vars("OpenUPS") msg.percent = float(bat['battery.charge']) msg.plugged_in = (str(bat['ups.status']) != "OB DISCHRG") msg.voltage = float(bat['battery.voltage']) if msg.plugged_in: msg.current = float(bat['input.current']) else: msg.current = -1 * float(bat['output.current']) * (float(bat['output.voltage']) / float(bat['battery.voltage'])) msg.temp = float(bat['battery.temperature']) success = True except: rospy.logerr("Cannot connect to power board.") self.stat_bat_pc = DiagnosticStatus(name="battery: PC",level=DiagnosticStatus.OK,message="OK") self.stat_bat_pc.values = [KeyValue("Voltage (V)",str(msg.voltage)), KeyValue("Percentage",str(msg.percent)), KeyValue("Current (A)",str(msg.current)), KeyValue("Temperature (C)",str(msg.temp)), KeyValue("Charging",str(msg.plugged_in))] if not success: self.stat_bat_pc.level = DiagnosticStatus.ERROR self.stat_bat_pc.message = "Cannot connect to the power board" elif msg.percent < SystemInfo.BAT_PERC_ERROR: self.stat_bat_pc.level = DiagnosticStatus.ERROR self.stat_bat_pc.message = "Battery almost empty" elif msg.percent < SystemInfo.BAT_PERC_WARN: self.stat_bat_pc.level = DiagnosticStatus.WARN self.stat_bat_pc.message = "Battery almost empty" return msg
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 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)
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 test_connect_debug(self): try: PyNUTClient(debug=True) except Exception: assert (False)
class NutDataExtractor: remove_keys = [ 'driver.version.internal', 'driver.version.usb', 'ups.beeper.status', 'driver.name', 'battery.mfr.date' ] tag_keys = [ 'battery.type', 'device.model', 'device.serial', 'driver.version', 'driver.version.data', 'device.mfr', 'device.type', 'ups.mfr', 'ups.model', 'ups.productid', 'ups.serial', 'ups.vendorid' ] 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 extract(self): try: ups_data = self.ups_client.list_vars(self.ups_name) return self.construct_object(ups_data) except: tb = traceback.format_exc() if verbose: print(f'Error connecting to NUT {host}:{port}') print(tb) exit(1) def convert_to_type(self, s): """ A function to convert a str to either integer or float. If neither, it will return the str. """ try: int_var = int(s) return int_var except ValueError: try: float_var = float(s) return float_var except ValueError: return s def construct_object(self, data: dict): """ Constructs NUT data into an object that can be sent directly to InfluxDB :param data: data received from NUT :param remove_keys: some keys which are considered superfluous :param tag_keys: some keys that are actually considered tags and not measurements :return: """ # Remove all items that are in the remove_keys array data = {k: v for (k, v) in data.items() if k not in self.remove_keys} # Map all tags tags = {k: v for (k, v) in data.items() if k in self.tag_keys} tags['host'] = variables['HOSTNAME'] # Everything else is a field value fields = { k: self.convert_to_type(v) for (k, v) in data.items() if k not in self.tag_keys } return {"fields": fields, "tags": tags}
class USV: name = 'USV' 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', ] def collect_data(self): self.load_data() self.add_extra_entries() return self.parsed_data # @staticmethod # def reformat_data(input_dict, dictionary): # output = OrderedDict() # for x in input_dict: # output[dictionary[x['dxsId']]] = x['value'] # return output # @retry(tries=2, delay=0) def load_data(self): data = OrderedDict() self.nut._connect() self.timestamp = datetime.now(self.tz) for key in self.id_fields.keys(): data[self.id_fields[key][0]] = self.id_fields[key][1](self.nut.get_var(self.nut_name, key)) # print(self.nut.var_description(self.nut_name,key)) # try: # print(str(self.nut.list_range(self.nut_name,key))) # except: # pass self.parsed_data = data def add_extra_entries(self): self.parsed_data['time_sec'] = int(self.timestamp.timestamp()) self.parsed_data['TIMESTAMP'] = datetime.fromtimestamp( self.parsed_data['time_sec'], self.tz).strftime('%Y-%m-%d %H:%M:%S') def correct_data(self): pass
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 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:
class TestClient(unittest.TestCase): 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 test_init_with_args(self): PyNUTClient(connect=False, login='******', password='******', host='test', port=1) def test_supports_context_manager(self): try: with PyNUTClient(connect=False) as client: pass except AttributeError: assert(False) def test_connect(self): try: PyNUTClient() except Exception: assert(False) def test_connect_debug(self): try: PyNUTClient(debug=True) except Exception: assert(False) 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_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 test_get_ups_list(self): ups_list = self.client.list_ups() self.assertEquals(type(ups_list), dict) self.assertEquals(len(ups_list), 2) self.assertEquals(ups_list[self.valid], self.valid_ups_name) def test_get_ups_list_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_ups) def test_get_ups_vars_valid_ups(self): vars = self.client.list_vars(self.valid) self.assertEquals(type(vars), dict) self.assertEquals(len(vars), 2) self.assertEquals(vars['battery.charge'], '100') def test_get_ups_vars_invalid_ups(self): self.assertRaises(PyNUTError, self.client.list_vars, self.invalid) def test_get_ups_vars_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_vars, self.valid) def test_get_ups_commands_valid_ups(self): commands = self.client.list_commands(self.valid) self.assertEquals(type(commands), dict) self.assertEquals(len(commands), 1) self.assertEquals(commands[self.valid], self.valid_command_desc) def test_get_ups_commands_invalid_ups(self): self.assertRaises(PyNUTError, self.client.list_commands, self.invalid) def test_get_ups_commands_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_commands, self.valid) def test_get_rw_vars_valid_ups(self): vars = self.client.list_rw_vars(self.valid) self.assertEquals(type(vars), dict) self.assertEquals(vars[self.valid], self.valid) def test_get_rw_vars_invalid_ups(self): self.assertRaises(PyNUTError, self.client.list_rw_vars, self.invalid) def test_set_rw_var_valid(self): try: self.client.set_var(self.valid, self.valid, self.valid) except PyNUTError: assert(False) def test_set_rw_var_invalid(self): self.assertRaises(PyNUTError, self.client.set_var, self.invalid, self.invalid, self.invalid) def test_set_rw_var_broken(self): self.assertRaises(PyNUTError, self.broken_client.set_var, self.valid, self.valid, self.valid) def test_run_ups_command_valid(self): try: self.client.run_command(self.valid, self.valid) except PyNUTError: assert(False) def test_run_ups_command_invalid(self): self.assertRaises(PyNUTError, self.client.run_command, self.invalid, self.invalid) def test_run_ups_command_broken(self): self.assertRaises(PyNUTError, self.broken_client.run_command, self.valid, self.valid) def test_fsd_valid_ups(self): try: self.client.fsd(self.valid) except PyNUTError: assert(False) def test_fsd_invalid_ups(self): self.assertRaises(PyNUTError, self.client.fsd, self.invalid) def test_fsd_broken(self): self.assertRaises(PyNUTError, self.broken_client.fsd, self.valid) def test_fsd_not_ok(self): self.assertRaises(PyNUTError, self.not_ok_client.fsd, self.valid) def test_help(self): self.assertEquals(self.client.help(), 'Commands: HELP VER GET LIST SET INSTCMD LOGIN LOGOUT USERNAME PASSWORD STARTTLS\n') def test_ver(self): self.assertEquals(self.client.ver(), 'Network UPS Tools upsd 2.7.1 - http://www.networkupstools.org/\n') def test_list_clients_valid(self): clients = self.client.list_clients(self.valid) self.assertEquals(type(clients), dict) self.assertEquals(clients[self.valid], [self.valid]) def test_list_clients_invalid(self): self.assertRaises(PyNUTError, self.client.list_clients, self.invalid) def test_list_clients_none(self): self.assertRaises(PyNUTError, self.client.list_clients) def test_list_clients_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_clients, self.valid) def test_num_logins(self): self.assertEquals(self.client.num_logins(self.valid), 1) def test_num_logins_broken(self): self.assertRaises(PyNUTError, self.broken_client.num_logins, self.valid) def test_description(self): self.assertEquals(self.client.description(self.valid), self.valid_desc) def test_description_broken(self): self.assertRaises(PyNUTError, self.broken_client.description, self.valid) def test_get(self): self.assertEquals(self.client.get(self.valid, self.valid), self.valid_value) def test_get_var_alias_for_get(self): self.assertEquals(self.client.get(self.valid, self.valid), self.client.get_var(self.valid, self.valid)) def test_get_broken(self): self.assertRaises(PyNUTError, self.broken_client.get, self.valid, self.valid) def test_var_description(self): self.assertEquals(self.client.var_description(self.valid, self.valid), self.valid_desc) def test_var_description_broken(self): self.assertRaises(PyNUTError, self.broken_client.var_description, self.valid, self.valid) def test_command_description(self): self.assertEquals(self.client.command_description(self.valid, self.valid), self.valid_desc) def test_command_description_broken(self): self.assertRaises(PyNUTError, self.broken_client.command_description, self.valid, self.valid) def test_list_enum(self): self.assertEquals(self.client.list_enum(self.valid, self.valid), [self.valid_desc]) def test_list_enum_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_enum, self.valid, self.valid) def test_list_range(self): self.assertEquals(self.client.list_range(self.valid, self.valid), [self.valid_desc]) def test_list_range_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_range, self.valid, self.valid) def test_var_type(self): self.assertEquals(self.client.var_type(self.valid, self.valid), "RW STRING:3") def test_var_type_broken(self): self.assertRaises(PyNUTError, self.broken_client.var_type, self.valid, self.valid)
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
from os import getenv from nut2 import PyNUTClient from thingspeak import Channel CHANNEL_ID = int(getenv("THINGSPEAK_CHANNEL_ID")) API_KEY = getenv("THINGSPEAK_API_KEY") UPS_NAME = getenv("NUT_UPS_NAME") channel = Channel(CHANNEL_ID, api_key=API_KEY) client = PyNUTClient() voltage = float(client.get_var(UPS_NAME, 'input.voltage')) print(voltage, channel.update({"field1": voltage}))
class TestClient(unittest.TestCase): 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 test_init_with_args(self): PyNUTClient(connect=False, login='******', password='******', host='test', port=1) def test_supports_context_manager(self): try: with PyNUTClient(connect=False) as client: pass except AttributeError: assert (False) def test_connect(self): try: PyNUTClient() except Exception: assert (False) def test_connect_debug(self): try: PyNUTClient(debug=True) except Exception: assert (False) 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_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 test_get_ups_list(self): ups_list = self.client.list_ups() self.assertEquals(type(ups_list), dict) self.assertEquals(len(ups_list), 2) self.assertEquals(ups_list[self.valid], self.valid_ups_name) def test_get_ups_list_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_ups) def test_get_ups_vars_valid_ups(self): vars = self.client.list_vars(self.valid) self.assertEquals(type(vars), dict) self.assertEquals(len(vars), 2) self.assertEquals(vars['battery.charge'], '100') def test_get_ups_vars_invalid_ups(self): self.assertRaises(PyNUTError, self.client.list_vars, self.invalid) def test_get_ups_vars_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_vars, self.valid) def test_get_ups_commands_valid_ups(self): commands = self.client.list_commands(self.valid) self.assertEquals(type(commands), dict) self.assertEquals(len(commands), 1) self.assertEquals(commands[self.valid], self.valid_command_desc) def test_get_ups_commands_invalid_ups(self): self.assertRaises(PyNUTError, self.client.list_commands, self.invalid) def test_get_ups_commands_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_commands, self.valid) def test_get_rw_vars_valid_ups(self): vars = self.client.list_rw_vars(self.valid) self.assertEquals(type(vars), dict) self.assertEquals(vars[self.valid], self.valid) def test_get_rw_vars_invalid_ups(self): self.assertRaises(PyNUTError, self.client.list_rw_vars, self.invalid) def test_set_rw_var_valid(self): try: self.client.set_var(self.valid, self.valid, self.valid) except PyNUTError: assert (False) def test_set_rw_var_invalid(self): self.assertRaises(PyNUTError, self.client.set_var, self.invalid, self.invalid, self.invalid) def test_set_rw_var_broken(self): self.assertRaises(PyNUTError, self.broken_client.set_var, self.valid, self.valid, self.valid) def test_run_ups_command_valid(self): try: self.client.run_command(self.valid, self.valid) except PyNUTError: assert (False) def test_run_ups_command_invalid(self): self.assertRaises(PyNUTError, self.client.run_command, self.invalid, self.invalid) def test_run_ups_command_broken(self): self.assertRaises(PyNUTError, self.broken_client.run_command, self.valid, self.valid) def test_fsd_valid_ups(self): try: self.client.fsd(self.valid) except PyNUTError: assert (False) def test_fsd_invalid_ups(self): self.assertRaises(PyNUTError, self.client.fsd, self.invalid) def test_fsd_broken(self): self.assertRaises(PyNUTError, self.broken_client.fsd, self.valid) def test_fsd_not_ok(self): self.assertRaises(PyNUTError, self.not_ok_client.fsd, self.valid) def test_help(self): self.assertEquals( self.client.help(), 'Commands: HELP VER GET LIST SET INSTCMD LOGIN LOGOUT USERNAME PASSWORD STARTTLS\n' ) def test_ver(self): self.assertEquals( self.client.ver(), 'Network UPS Tools upsd 2.7.1 - http://www.networkupstools.org/\n') def test_list_clients_valid(self): clients = self.client.list_clients(self.valid) self.assertEquals(type(clients), dict) self.assertEquals(clients[self.valid], [self.valid]) def test_list_clients_invalid(self): self.assertRaises(PyNUTError, self.client.list_clients, self.invalid) def test_list_clients_none(self): self.assertRaises(PyNUTError, self.client.list_clients) def test_list_clients_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_clients, self.valid) def test_num_logins(self): self.assertEquals(self.client.num_logins(self.valid), 1) def test_num_logins_broken(self): self.assertRaises(PyNUTError, self.broken_client.num_logins, self.valid) def test_description(self): self.assertEquals(self.client.description(self.valid), self.valid_desc) def test_description_broken(self): self.assertRaises(PyNUTError, self.broken_client.description, self.valid) def test_get(self): self.assertEquals(self.client.get(self.valid, self.valid), self.valid_value) def test_get_var_alias_for_get(self): self.assertEquals(self.client.get(self.valid, self.valid), self.client.get_var(self.valid, self.valid)) def test_get_broken(self): self.assertRaises(PyNUTError, self.broken_client.get, self.valid, self.valid) def test_var_description(self): self.assertEquals(self.client.var_description(self.valid, self.valid), self.valid_desc) def test_var_description_broken(self): self.assertRaises(PyNUTError, self.broken_client.var_description, self.valid, self.valid) def test_command_description(self): self.assertEquals( self.client.command_description(self.valid, self.valid), self.valid_desc) def test_command_description_broken(self): self.assertRaises(PyNUTError, self.broken_client.command_description, self.valid, self.valid) def test_list_enum(self): self.assertEquals(self.client.list_enum(self.valid, self.valid), [self.valid_desc]) def test_list_enum_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_enum, self.valid, self.valid) def test_list_range(self): self.assertEquals(self.client.list_range(self.valid, self.valid), [self.valid_desc]) def test_list_range_broken(self): self.assertRaises(PyNUTError, self.broken_client.list_range, self.valid, self.valid) def test_var_type(self): self.assertEquals(self.client.var_type(self.valid, self.valid), "RW STRING:3") def test_var_type_broken(self): self.assertRaises(PyNUTError, self.broken_client.var_type, self.valid, self.valid)
def test_init_with_args(self): PyNUTClient(connect=False, login='******', password='******', host='test', port=1)
def test_supports_context_manager(self): try: with PyNUTClient(connect=False) as client: pass except AttributeError: assert (False)
#!/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_connect(self): try: PyNUTClient() except Exception: assert (False)
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_broken(self): telnetlib.Telnet = MockServer client = PyNUTClient(login=self.valid, password=self.valid, connect=False) self.assertRaises(PyNUTError, client._connect)