The Dashboard Version is: v{}
".format(self.board.version.val), "UTF-8") content += bytes("The API Endpoint (JSON) is located here: /json/
", "UTF-8") content += bytes("", "UTF-8") self.send_response(200) self.send_header("Content-type", ctype) self.send_header("Content-Length", len(content)) self.end_headers() self.wfile.write(content) def log_message(self, *args): """Overwrite so messages are not logged to STDOUT""" pass def log_request(self, code='-', size='-'): """Log an accepted request. This is called by send_response(). """ if isinstance(code, HTTPStatus): code = code.value logger.debug("{} - - [{}] \"{}\" {} {}".format(self.address_string(), self.log_date_time_string(), self.requestline, str(code), str(size))) class ThreadedHTTPServer(object): """Runs BaseHTTPServer in a thread Lets you start and stop an instance of SimpleHTTPServer. """ def __init__(self, host, port, board=None, board_lock=None, name=None): """Prepare thread and socket server Creates the socket server that will use the HTTP request handler. Also prepares the thread to run the serve_forever method of the socket server as a daemon once it is started """ request_handler = QuietBaseHTTPRequestHandler request_handler.board = board request_handler.board_lock = board_lock socketserver.TCPServer.allow_reuse_address = True self.server = socketserver.TCPServer((host, port), request_handler) self.server_thread = threading.Thread(name=name, target=self.server.serve_forever) self.server_thread.daemon = True def __enter__(self): self.start() return self def __exit__(self, type, value, traceback): self.stop() def start(self): """Start the HTTP server Starts the serve_forever method of Socket running the request handler as a daemon thread """ self.server_thread.start() def stop(self): """Stop the HTTP server Stops the server and cleans up the port assigned to the socket """ self.server.shutdown() self.server.server_close() # Benefit of using class instead of function: Can use clean signature instead of kwargs..! class DashboardPrinter(threading.Thread): def __init__(self, group=None, target=None, name="DB_Printer", board=None, board_lock=None, interval=None, daemon=True, args=(), kwargs=None, ): super().__init__(group, target, name, daemon=daemon, args=args, kwargs=kwargs) self.board = board self.board_lock = board_lock self.interval = interval def run(self): while True: start = time.time() with self.board_lock: end = time.time() logger.info("Getting print lock took: {:.3f} seconds".format(end - start)) clear() self.board.display() time.sleep(self.interval) class DashboardUpdater(threading.Thread): def __init__(self, group=None, target=None, name="DB_Updater", board=None, board_lock=None, interval=None, daemon=True, args=(), kwargs=None, ): super().__init__(group, target, name, daemon=daemon, args=args, kwargs=kwargs) self.board = board self.board_lock = board_lock self.interval = interval def run(self): while True: logger.debug("Updating Dashboard") total_start = time.time() start = time.time() with self.board_lock: end = time.time() logger.debug("Getting update1 lock took: {:.3f} seconds".format(end - start)) self.board.update_load() self.board.update_uptime() self.board.update_cpu_temp() self.board.update_memory() self.board.update_storage() self.board.update_ip_network_data() time.sleep(0.05) start = time.time() with self.board_lock: end = time.time() logger.debug("Getting update2 lock took: {:.3f} seconds".format(end - start)) self.board.update_network() self.board.update_bitcoin_dir() self.board.read_bitcoin_config() self.board.update_chain() time.sleep(0.05) start = time.time() with self.board_lock: end = time.time() logger.debug("Getting update3 lock took: {:.3f} seconds".format(end - start)) self.board.update_bitcoin_binaries() self.board.check_bitcoind_is_running() self.board.update_bitcoin_daemon_version() self.board.update_bitcoin_data() time.sleep(0.05) start = time.time() with self.board_lock: end = time.time() logger.debug("Getting update4 lock took: {:.3f} seconds".format(end - start)) self.board.update_lnd_dirs() self.board.read_lnd_config() self.board.check_lnd_is_running() self.board.update_lnd_wallet_is_locked() self.board.update_lnd_alias() self.board.update_lnd_data() time.sleep(0.05) start = time.time() with self.board_lock: end = time.time() logger.debug("Getting update5 lock took: {:.3f} seconds".format(end - start)) self.board.update_public_ip() self.board.update_bitcoin_public_port() self.board.check_public_ip_lnd_port() self.board.check_public_ip_bitcoin_port() time.sleep(0.05) total_end = time.time() logger.info("Dashboard Value Update took: {:.3f} seconds".format(total_end - total_start)) time.sleep(self.interval) class Metric(object): STYLES = ["default", "red", "green", "yellow", "gray", "cyan"] def __init__(self, val=None, txt=None, prefix=None, suffix=None, style="default", allow_empty=False): self.val = val # "raw" value of Metric self._txt = txt # text of "raw" value intended for printing to console (e.g. Memory in MiB instead of Bytes) self.prefix = prefix self.suffix = suffix if style not in self.STYLES: raise ValueError("unknown style!") self.style = style self.allow_empty = allow_empty # when this is False (default) "prefix + n/a + suffix" will be printed @property def txt(self): if self._txt: return self._txt elif self._txt == "": return "" else: if self.val: return "{}".format(self.val) else: return None @txt.setter def txt(self, value): self._txt = value def __repr__(self): if self.val: return "<{0}: {1}>".format(self.__class__.__name__, self.val) return "<{0}: n/a>".format(self.__class__.__name__) def __str__(self): return self.apply_style(string=self.to_txt(), style=self.style) def apply_style(self, string, style=None): if not style: style = "default" if "n/a" in string: return _purple(string) elif string: if style == "red": return _red(string) elif style == "green": return _green(string) elif style == "yellow": return _yellow(string) elif style == "gray": return _gray(string) elif style == "cyan": return _cyan(string) else: return string else: if self.allow_empty: return "" else: return _purple(string) def to_dct(self): dct = dict() # copy dict except for _txt and allow_empty for k, v in self.__dict__.items(): if k in ["_txt", "allow_empty"]: continue dct.update({k: v}) # add txt representation dct.update({"txt": self.to_txt()}) return dct def to_txt(self): if self.prefix is None: prefix = "" else: prefix = self.prefix if self.suffix is None: suffix = "" else: suffix = self.suffix if self.txt: return "{0}{1}{2}".format(prefix, self.txt, suffix) else: if self.allow_empty: return "" else: return "{0}n/a{1}".format(prefix, suffix) class Dashboard(object): def __init__(self, currency, interface=IF_NAME, timeout=TIMEOUT): self.currency = CRYPTO_CURRENCIES[currency] # Attributes that are used internally but not displayed directly # self.interface = interface self.timeout = timeout self.ipv4_addresses = list() self.lpv6_addresses = list() self.bitcoin_dir = None self.lnd_dir = None self.lnd_macaroon_dir = None self.bitcoin_config = None self.lnd_config = None self.bitcoin_daemon = None self.bitcoin_cli = None self.bitcoin_local_adresses = list() self.lnd_is_running = False self.lnd_is_syned = False self.lnd_wallet_is_locked = True # Dashboard Metrics (all values that are displayed somewhere) - in use # self.name = Metric() self.version = Metric() # System data self.load_one = Metric() self.load_five = Metric() self.load_fifteen = Metric() self.cpu_temp = Metric(suffix="°C") self.memory_total = Metric(suffix="M", style="green") self.memory_avail = Metric(suffix="M", style="green") # Storage self.sd_total_abs = Metric(suffix="G", style="green") self.sd_free_abs = Metric(suffix="G", style="green") self.sd_free = Metric(suffix="%", style="green") self.hdd_total_abs = Metric(suffix="G", style="green") self.hdd_free_abs = Metric(suffix="G", style="green") self.hdd_free = Metric(suffix="%", style="green") # IP Network/Traffic Info self.local_ip = Metric(style="green") self.network_tx = Metric() self.network_rx = Metric() self.public_ip = Metric(style="green") self.public_bitcoin_port = Metric(style="green") self.public_bitcoin_port_status = Metric(allow_empty=True) # Bitcoin / Chain Info self.network = Metric(style="default") self.chain = Metric("main", suffix="net", style="green") self.bitcoin_cli_version = Metric(style="green") self.bitcoin_version = Metric(style="green") self.bitcoin_is_running = False self.bitcoin_log_msgs = None self.sync_behind = Metric() self.sync_percentage = Metric(suffix="%", style="green") self.sync_status = Metric() # self.last_block = Metric() self.block_height = Metric() self.btc_line2 = Metric() self.mempool = Metric() # Tor (The Onion Router) self.tor_active = Metric(allow_empty=True) self.onion_addr = Metric() self.lnd_alias = Metric(style="green") self.lnd_version = Metric(style="green") self.lnd_lncli_version = Metric(style="green") self.lnd_base_msg = Metric(allow_empty=True) self.lnd_channel_msg = Metric(allow_empty=True) self.lnd_channel_balance = Metric() self.lnd_channels_online = Metric() self.lnd_channels_total = Metric() self.lnd_external = Metric(style="yellow") self.public_ip_lnd_port_status = Metric(allow_empty=True) self.lnd_wallet_balance = Metric() self.lnd_wallet_lock_status = Metric() # Dashboard Metrics (all values that are displayed somewhere) - currently not in use # self.uptime = Metric() self.bitcoin_ipv4_reachable = Metric() self.bitcoin_ipv4_limited = Metric() self.bitcoin_ipv6_reachable = Metric() self.bitcoin_ipv6_limited = Metric() self.bitcoin_onion_reachable = Metric() self.bitcoin_onion_limited = Metric() def __repr__(self): return "<{0}: Version: {1}>".format(self.__class__.__name__, self.version) def all_metrics(self): """Introspection: return list of all attributes that are Metric instances""" return [{m: getattr(self, m).to_dct()} for m in [a for a in dir(self)] if isinstance(getattr(self, m), Metric)] def update_load(self): one, five, fifteen = os.getloadavg() _cpu_count = os.cpu_count() self.load_one.val = one self.load_one.txt = "{:.2f}".format(self.load_one.val) self.load_five.val = five self.load_five.txt = "{:.2f}".format(self.load_five.val) self.load_fifteen.val = fifteen self.load_fifteen.txt = "{:.2f}".format(self.load_fifteen.val) if float(self.load_one.val) < _cpu_count * 0.5: self.load_one.style = "green" elif float(self.load_one.val) < _cpu_count: self.load_one.style = "yellow" else: self.load_one.style = "red" if float(self.load_five.val) < _cpu_count * 0.5: self.load_five.style = "green" elif float(self.load_five.val) < _cpu_count: self.load_five.style = "yellow" else: self.load_five.style = "red" if float(self.load_fifteen.val) < _cpu_count * 0.5: self.load_fifteen.style = "green" elif float(self.load_fifteen.val) < _cpu_count: self.load_fifteen.style = "yellow" else: self.load_fifteen.style = "red" def update_uptime(self): if not os.path.exists("/proc/uptime"): return with open("/proc/uptime", "r") as f: _uptime_seconds = float(f.readline().split()[0]) self.uptime.val = int(timedelta(seconds=_uptime_seconds).total_seconds()) self.uptime.txt = "{}".format(self.uptime.val) def update_cpu_temp(self): if not os.path.exists("/sys/class/thermal/thermal_zone0/temp"): return with open("/sys/class/thermal/thermal_zone0/temp", "r") as f: content = int(f.readline().split("\n")[0]) self.cpu_temp.val = content / 1000.0 self.cpu_temp.txt = "{:.0f}".format(self.cpu_temp.val) if self.cpu_temp.val > 80.0: self.cpu_temp.style = "red" def update_memory(self): if not os.path.exists("/proc/meminfo"): return with open("/proc/meminfo", "r") as f: content = f.readlines() _meminfo = dict((i.split()[0].rstrip(':'), int(i.split()[1])) for i in content) self.memory_total.val = _meminfo['MemTotal'] # e.g. 949440 self.memory_total.txt = "{:.0f}".format(self.memory_total.val / 1024) self.memory_avail.val = _meminfo['MemAvailable'] # e.g. 457424 self.memory_avail.txt = "{:.0f}".format(self.memory_avail.val / 1024) if self.memory_avail.val < 100000: self.memory_total.style = "yellow" self.memory_avail.style = "yellow" def update_storage(self): """use statvfs interface to get free/used disk space statvfs.f_frsize * statvfs.f_blocks # Size of filesystem in bytes statvfs.f_frsize * statvfs.f_bfree # Actual number of free bytes statvfs.f_frsize * statvfs.f_bavail # Number of free bytes that ordinary users are allowed to use """ if not os.path.exists("/"): return statvfs_sd = os.statvfs('/') _sd_total_abs = statvfs_sd.f_frsize * statvfs_sd.f_blocks _sd_free_abs = statvfs_sd.f_frsize * statvfs_sd.f_bavail _sd_free = _sd_free_abs / _sd_total_abs * 100 if not os.path.exists("/mnt/hdd"): return statvfs_hdd = os.statvfs("/mnt/hdd") _hdd_total_abs = statvfs_hdd.f_frsize * statvfs_hdd.f_blocks # _hdd_free_abs = statvfs_hdd.f_frsize * statvfs_hdd.f_bfree _hdd_free_abs = statvfs_hdd.f_frsize * statvfs_hdd.f_bavail _hdd_free = _hdd_free_abs / _hdd_total_abs * 100 self.sd_total_abs.val = _sd_total_abs / 1024.0 / 1024.0 / 1024.0 self.sd_total_abs.txt = "{:.0f}".format(self.sd_total_abs.val) self.sd_free_abs.val = _sd_free_abs / 1024.0 / 1024.0 / 1024.0 self.sd_free_abs.txt = "{:.0f}".format(self.sd_free_abs.val) self.sd_free.val = _sd_free self.sd_free.txt = "{:.0f}".format(self.sd_free.val) self.hdd_total_abs.val = _hdd_total_abs / 1024.0 / 1024.0 / 1024.0 self.hdd_total_abs.txt = "{:.0f}".format(self.hdd_total_abs.val) self.hdd_free_abs.val = _hdd_free_abs / 1024.0 / 1024.0 / 1024.0 self.hdd_free_abs.txt = "{:.0f}".format(self.hdd_free_abs.val) self.hdd_free.val = _hdd_free self.hdd_free.txt = "{:.0f}".format(self.hdd_free.val) if self.hdd_free.val < 20: self.hdd_free.style = "yellow" elif self.hdd_free.val < 10: self.hdd_free.style = "red" def update_ip_network_data(self): self.ipv4_addresses = get_ipv4_addresses(self.interface) self.ipv6_addresses = get_ipv6_addresses(self.interface) self.local_ip.val = self.ipv4_addresses[0] if not os.path.exists("/sys/class/net/{0}/statistics/rx_bytes".format(self.interface)): return with open("/sys/class/net/{0}/statistics/rx_bytes".format(self.interface), 'r') as f: _rx_bytes = float(f.readline().split()[0]) if not os.path.exists("/sys/class/net/{0}/statistics/tx_bytes".format(self.interface)): return with open("/sys/class/net/{0}/statistics/tx_bytes".format(self.interface), 'r') as f: _tx_bytes = float(f.readline().split()[0]) if _tx_bytes / 1024.0 / 1024.0 / 1024.0 / 1024.0 > 1: _tx_suffix = "TiB" _tx_bytes_val = _tx_bytes / 1024.0 / 1024.0 / 1024.0 / 1024.0 elif _tx_bytes / 1024.0 / 1024.0 / 1024.0 > 1: _tx_suffix = "GiB" _tx_bytes_val = _tx_bytes / 1024.0 / 1024.0 / 1024.0 elif _tx_bytes / 1024.0 / 1024.0 > 1: _tx_suffix = "MiB" _tx_bytes_val = _tx_bytes / 1024.0 / 1024.0 elif _tx_bytes / 1024.0 > 1: _tx_suffix = "KiB" _tx_bytes_val = _tx_bytes / 1024.0 else: _tx_suffix = "Byte" _tx_bytes_val = _tx_bytes if _rx_bytes / 1024.0 / 1024.0 / 1024.0 / 1024.0 > 1: _rx_suffix = "TiB" _rx_bytes_val = _rx_bytes / 1024.0 / 1024.0 / 1024.0 / 1024.0 elif _rx_bytes / 1024.0 / 1024.0 / 1024.0 > 1: _rx_suffix = "GiB" _rx_bytes_val = _rx_bytes / 1024.0 / 1024.0 / 1024.0 elif _rx_bytes / 1024.0 / 1024.0 > 1: _rx_suffix = "MiB" _rx_bytes_val = _rx_bytes / 1024.0 / 1024.0 elif _rx_bytes / 1024.0 > 1: _rx_suffix = "KiB" _rx_bytes_val = _rx_bytes / 1024.0 else: _rx_suffix = "Byte" _rx_bytes_val = _rx_bytes self.network_rx = Metric(_rx_bytes_val, txt="{:.1f}".format(_rx_bytes_val), suffix=_rx_suffix) self.network_tx = Metric(_tx_bytes_val, txt="{:.1f}".format(_tx_bytes_val), suffix=_tx_suffix) def update_network(self): # load network (bitcoin, litecoin, ..?!) with open(NETWORK_FILE) as f: content = f.readline().split("\n")[0] if content not in list(CRYPTO_CURRENCIES.keys()): raise ValueError("unexpected value in {}: {}".format(NETWORK_FILE, content)) self.network.val = content if not self.network.val == self.currency["title"].lower(): raise ValueError("Crypto Currency in {} does not match selection!".format(NETWORK_FILE)) def update_bitcoin_dir(self): self.bitcoin_dir = "{0}/.{1}".format(BITCOIN_HOME, self.network.val) def read_bitcoin_config(self): _bitcoin_conf = "{0}/{1}.conf".format(self.bitcoin_dir, self.network.val) if not os.path.exists(_bitcoin_conf): logger.warning("{} config not found: {}".format(self.currency["title"], _bitcoin_conf)) return # need to do a little "hack" here as ConfigParser expects sections which bitcoin.conf does not have with open(_bitcoin_conf, 'r') as f: _config_string = '[DEFAULT]\n' + f.read() config = configparser.ConfigParser(strict=False) config.read_string(_config_string) self.bitcoin_config = config # access with self.bitcoin_config["DEFAULT"]... def update_chain(self): # get chain (mainnet or testnet) try: if self.bitcoin_config["DEFAULT"]["testnet"] == "1": self.chain.val = "test" except KeyError: pass # this is expected - if testnet is not present then mainnet is active except TypeError as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) def update_bitcoin_binaries(self): cmds = "which {}d".format(self.network.val) _bitcoind, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: self.bitcoin_daemon = _bitcoind.split("\n")[0] except IndexError as err: logger.warning("Error: {}".format(err)) else: raise Exception("could not find network chain daemin tool: {}d".format(self.network.val)) cmds = "which {}-cli".format(self.network.val) _bitcoin_cli, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: self.bitcoin_cli = _bitcoin_cli.split("\n")[0] except IndexError as err: logger.warning("Error: {}".format(err)) else: raise Exception("could not find network chain cli tool: {}-cli".format(self.network.val)) def check_bitcoind_is_running(self): # check if bitcoind is running cmds = "ps aux | grep -e \"{}.*-daemon\" | grep -v grep | wc -l".format(self.currency['daemon']) _bitcoind_running, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: if _bitcoind_running.split("\n")[0] == "0": self.bitcoin_is_running = False logger.warning("{} is not running".format(self.currency['daemon'])) return True else: self.bitcoin_is_running = True return True except IndexError as err: logger.warning("Error: {}".format(err)) return False def update_bitcoind_log(self): # check bitcoind log if self.chain.val == "test": cmds = "sudo -u bitcoin tail -n 20 {}/{}/debug.log".format(self.bitcoin_dir, self.currency["testnet_dir"]) else: cmds = "sudo -u bitcoin tail -n 20 {}/debug.log".format(self.bitcoin_dir) _bitcoind_log, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: self.bitcoin_log_msgs = [_bitcoind_log.split("\n")[-3], _bitcoind_log.split("\n")[-2]] except IndexError as err: logger.warning("Error: {}".format(err)) def update_bitcoin_daemon_version(self): # get bitcoin version from daemon (bitcoind -version) cmds = "{} -datadir={} -version".format(self.bitcoin_cli, self.bitcoin_dir) _version_info, success, timed_out = run_user(cmds, timeout=self.timeout) if success: self.bitcoin_version.val = re.match("^.* v(.*$)", _version_info).groups()[0] self.bitcoin_version.prefix = "v" def update_bitcoin_data(self): self.sync_status.val = None self.sync_status.txt = None self.sync_status.style = "default" self.sync_percentage.val = None self.sync_percentage.txt = None self.sync_percentage.style = "green" # block count/height cmds = "{} -datadir={} getblockcount".format(self.bitcoin_cli, self.bitcoin_dir) _block_count, success, timed_out = run_user(cmds, timeout=self.timeout) if success: # reset self.bitcoin_log_msgs - which might have been set by update_bitcoind_log() self.bitcoin_log_msgs = None try: self.block_height.val = int(_block_count.split("\n")[0]) self.block_height.txt = "{}".format(self.block_height.val) except IndexError as err: logger.warning("Error: {}".format(err)) else: # unable to run getblockcount.. maybe bitcoind is processing a long running job (e.g. txindex) TODO # try: # last_line = _block_count.split("\n")[-2] # except AttributeError: # pass self.update_bitcoind_log() # get blockchain (sync) status/percentage cmds = "{} -datadir={} getblockchaininfo".format(self.bitcoin_cli, self.bitcoin_dir) _chain_info, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: _block_verified = json.loads(_chain_info)["blocks"] _block_diff = int(self.block_height.val) - int(_block_verified) _progress = json.loads(_chain_info)["verificationprogress"] self.sync_percentage.val = _progress self.sync_percentage.txt = "{:.2f}".format(self.sync_percentage.val * 100) if _block_diff == 0: # fully synced self.sync_status.val = _block_diff self.sync_status.txt = "OK" self.sync_status.style = "green" self.sync_behind = " " elif _block_diff == 1: # fully synced self.sync_status.val = _block_diff self.sync_status.txt = "OK" self.sync_status.style = "green" self.sync_behind = "-1 block" elif _block_diff <= 10: self.sync_status.val = _block_diff self.sync_status.txt = "catchup" self.sync_status.style = "red" self.sync_percentage.style = "red" self.sync_behind = "-{} blocks".format(_block_diff) else: self.sync_status.val = _block_diff self.sync_status.txt = "progress" self.sync_status.style = "red" self.sync_percentage.style = "red" self.sync_behind = "-{} blocks".format(_block_diff) except (KeyError, TypeError) as err: # catch if result is None or expected key not present logger.warning("Error: {}".format(err)) else: logger.debug("Error: getblockchaininfo") # mempool info cmds = "{} -datadir={} getmempoolinfo".format(self.bitcoin_cli, self.bitcoin_dir) _mempool_info, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: self.mempool.val = json.loads(_mempool_info)["size"] except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) # bitcoin network connectivity info cmds = "{} -datadir={} getnetworkinfo".format(self.bitcoin_cli, self.bitcoin_dir) _network_info, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: for nw in json.loads(_network_info)["networks"]: if nw["name"] == "ipv4": if nw["reachable"]: self.bitcoin_ipv4_reachable.val = True self.bitcoin_ipv4_reachable.txt = "True" self.bitcoin_ipv4_reachable.style = "green" else: self.bitcoin_ipv4_reachable.val = False self.bitcoin_ipv4_reachable.txt = "False" self.bitcoin_ipv4_reachable.style = "red" if nw["limited"]: self.bitcoin_ipv4_limited.val = True self.bitcoin_ipv4_limited.txt = "True" self.bitcoin_ipv4_limited.style = "green" else: self.bitcoin_ipv4_limited.val = False self.bitcoin_ipv4_limited.txt = "False" self.bitcoin_ipv4_limited.style = "red" if nw["name"] == "ipv6": if nw["reachable"]: self.bitcoin_ipv6_reachable.val = True self.bitcoin_ipv6_reachable.txt = "True" self.bitcoin_ipv6_reachable.style = "green" else: self.bitcoin_ipv6_reachable.val = False self.bitcoin_ipv6_reachable.txt = "False" self.bitcoin_ipv6_reachable.style = "red" if nw["limited"]: self.bitcoin_ipv6_limited.val = True self.bitcoin_ipv6_limited.txt = "True" self.bitcoin_ipv6_limited.style = "green" else: self.bitcoin_ipv6_limited.val = False self.bitcoin_ipv6_limited.txt = "False" self.bitcoin_ipv6_limited.style = "red" if nw["name"] == "onion": if nw["reachable"]: self.bitcoin_onion_reachable.val = True self.bitcoin_onion_reachable.txt = "True" self.bitcoin_onion_reachable.style = "green" else: self.bitcoin_onion_reachable.val = False self.bitcoin_onion_reachable.txt = "False" self.bitcoin_onion_reachable.style = "red" if nw["limited"]: self.bitcoin_onion_limited.val = True self.bitcoin_onion_limited.txt = "True" self.bitcoin_onion_limited.style = "green" else: self.bitcoin_onion_limited.val = False self.bitcoin_onion_limited.txt = "False" self.bitcoin_onion_limited.style = "red" except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) self.bitcoin_local_adresses = list() try: for la in json.loads(_network_info)["localaddresses"]: if ":" in la["address"]: if la["address"] in self.ipv6_addresses: self.bitcoin_local_adresses.append("[{}]:{}".format(la["address"], la["port"])) elif ".onion" in la["address"]: self.bitcoin_local_adresses.append("{}:{}".format(la["address"], la["port"])) if self.bitcoin_onion_reachable: self.tor_active = Metric("+ Tor") else: self.tor_active = Metric("+ Tor?") else: self.bitcoin_local_adresses.append("{}:{}".format(la["address"], la["port"])) except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) def update_lnd_dirs(self): # set datadir - requires network and chain to be set/checked self.lnd_dir = "/home/bitcoin/.lnd" self.lnd_macaroon_dir = "/home/bitcoin/.lnd/data/chain/{0}/{1}net".format(self.network.val, self.chain.val) def read_lnd_config(self): _lnd_conf = "{}/lnd.conf".format(self.lnd_dir) if not os.path.exists(_lnd_conf): return config = configparser.ConfigParser(strict=False) config.read(_lnd_conf) self.lnd_config = config def check_lnd_is_running(self): # check if lnd is running cmds = "ps aux | grep -e \"bin\/lnd\" | grep -v grep | wc -l" _lnd_running, success, timed_out = run_user(cmds, timeout=self.timeout) if success: try: if _lnd_running.split("\n")[0] == "0": self.lnd_is_running = False # print("WARN: LND not running!") else: self.lnd_is_running = True return True except IndexError as err: logger.warning("Error: {}".format(err)) return False def update_lnd_wallet_is_locked(self): # LN Wallet Lock Status cmds = "sudo tail -n 1 /mnt/hdd/lnd/logs/{0}/{1}net/lnd.log".format(self.network.val, self.chain.val) _ln_lock_status_log, success, timed_out = run_user(cmds) if success: if re.match(".*unlock.*", _ln_lock_status_log): self.lnd_wallet_lock_status = Metric("\U0001F512", style="red") self.lnd_wallet_lock_status.val = True self.lnd_wallet_is_locked = True else: self.lnd_wallet_lock_status = Metric("\U0001F513", style="green") self.lnd_wallet_lock_status.val = False self.lnd_wallet_is_locked = False return False return True # def _update_lncli_version(self): # # get lnd client version client # cmds = "/usr/local/bin/lncli --version" # _ln_client_version, success, timed_out = run_user(cmds, timeout=self.timeout) # if success: # try: # line = _ln_client_version.split("\n")[0] # self.lnd_lncli_version.raw = line.split(" ")[2] # self.lnd_lncli_version = self.lnd_lncli_version.raw # except IndexError as err: # logger.warning("Error: {}".format(err)) def update_lnd_alias(self): try: self.lnd_alias.val = self.lnd_config["Application Options"]["alias"] except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) def update_lnd_data(self): # reset any data that might be changed in this method self.lnd_base_msg.val = None self.lnd_base_msg.txt = None self.lnd_base_msg.style = "default" self.lnd_version.val = None self.lnd_version.txt = None self.lnd_version.style = "green" self.lnd_external.val = None self.lnd_external.txt = None self.lnd_external.style = "yellow" self.lnd_channel_msg.val = None self.lnd_channel_msg.txt = None self.lnd_channel_msg.style = "default" self.lnd_wallet_balance.val = None self.lnd_wallet_balance.txt = None self.lnd_wallet_balance.style = "default" self.lnd_channel_balance.val = None self.lnd_channel_balance.txt = None self.lnd_channel_balance.style = "default" self.lnd_channels_online.val = None self.lnd_channels_online.txt = None self.lnd_channels_online.style = "default" self.lnd_channels_total.val = None self.lnd_channels_total.txt = None self.lnd_channels_total.style = "default" self.lnd_is_syned = False # If LND is not running exit if not self.lnd_is_running: return # If LN wallet is locked exit if self.lnd_wallet_is_locked: self.lnd_base_msg.val = "\U0001F512Locked" self.lnd_base_msg.style = "red" return cmds = ("sudo -u bitcoin /usr/local/bin/lncli --macaroonpath={}/readonly.macaroon " "--tlscertpath={}/tls.cert getinfo 2>/dev/null".format(self.lnd_macaroon_dir, self.lnd_dir)) _ln_get_info, success, timed_out = run_user(cmds) if success: if not _ln_get_info: self.lnd_base_msg.val = "Not Started/Ready Yet" self.lnd_base_msg.style = "red" else: try: self.lnd_version.val = json.loads(_ln_get_info)["version"].split(" ")[0] except (IndexError, KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) try: self.lnd_external.val = json.loads(_ln_get_info)["uris"][0] except (IndexError, KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) try: if not json.loads(_ln_get_info)["synced_to_chain"]: self.lnd_is_syned = False else: self.lnd_is_syned = True except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) if self.lnd_is_syned: # synched_to_chain is True cmds = ("sudo -u bitcoin /usr/local/bin/lncli " "--macaroonpath={}/readonly.macaroon --tlscertpath={}/tls.cert " "walletbalance 2>/dev/null".format(self.lnd_macaroon_dir, self.lnd_dir)) _ln_wallet_balance, success, timed_out = run_user(cmds) if success: try: self.lnd_wallet_balance.val = int(json.loads(_ln_wallet_balance)["confirmed_balance"]) self.lnd_wallet_balance.txt = "{}".format(self.lnd_wallet_balance.val) self.lnd_wallet_balance.style = "yellow" except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) self.lnd_wallet_balance.val = None self.lnd_wallet_balance.txt = None cmds = ("sudo -u bitcoin /usr/local/bin/lncli " "--macaroonpath={}/readonly.macaroon --tlscertpath={}/tls.cert " "channelbalance 2>/dev/null".format(self.lnd_macaroon_dir, self.lnd_dir)) _ln_channel_balance, success, timed_out = run_user(cmds) if success: try: self.lnd_channel_balance.val = int(json.loads(_ln_channel_balance)["balance"]) self.lnd_channel_balance.txt = "{}".format(self.lnd_channel_balance.val) self.lnd_channel_balance.style = "yellow" except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) self.lnd_channel_balance.val = None self.lnd_channel_balance.txt = None try: self.lnd_channels_online.val = int(json.loads(_ln_get_info)["num_active_channels"]) self.lnd_channels_online.txt = "{}".format(self.lnd_channels_online.val) except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) self.lnd_channels_online.val = None self.lnd_channels_online.txt = None except json.decoder.JSONDecodeError as err: # catch if LND is unable to respond logger.warning("Error: {}".format(err)) self.lnd_channels_online.val = None self.lnd_channels_online.txt = None cmds = ("sudo -u bitcoin /usr/local/bin/lncli " "--macaroonpath={}/readonly.macaroon --tlscertpath={}/tls.cert " "listchannels 2>/dev/null".format(self.lnd_macaroon_dir, self.lnd_dir)) _ln_list_channels, success, timed_out = run_user(cmds) if success: try: self.lnd_channels_total.val = len(json.loads(_ln_list_channels)["channels"]) except (KeyError, TypeError) as err: # catch if None, expected index/key not present logger.warning("Error: {}".format(err)) else: # LND is not synched # is Bitcoind running?! if not self.bitcoin_is_running: self.lnd_base_msg.val = "{} not running or not ready".format(self.currency['daemon']) self.lnd_base_msg.vale = self.lnd_base_msg.val self.lnd_base_msg.style = "red" return self.lnd_base_msg.val = "Waiting for chain sync" self.lnd_base_msg.txt = self.lnd_base_msg.val self.lnd_base_msg.style = "red" cmds = ("sudo -u bitcoin tail -n 10000 " "/mnt/hdd/lnd/logs/{}/{}net/lnd.log".format(self.network.val, self.chain.val)) _ln_item, success, timed_out = run_user(cmds) if not success: self.lnd_channel_msg.val = "?!" self.lnd_channel_msg.style = "red" else: _last_match = "" for line in _ln_item.split("\n"): obj = re.match(".*\(height=(\d+).*", line) if obj: _last_match = obj.groups()[0] else: obj = re.match(".*Caught up to height (\d+)$", line) if obj: _last_match = obj.groups()[0] try: _last_match = int(_last_match) except ValueError: _last_match = 0 if self.block_height.val: if int(_last_match) > 0: self.lnd_channel_msg.val = int(_last_match) self.lnd_channel_msg.txt = "-> scanning {}/{}".format(_last_match, self.block_height) self.lnd_channel_msg.style = "red" else: self.lnd_channel_msg.val = int(_last_match) self.lnd_channel_msg.txt = "-> scanning ??/{}".format(self.block_height) self.lnd_channel_msg.style = "red" def update_public_ip(self): try: f = urlopen('http://v4.ipv6-test.com/api/myip.php') self.public_ip.val = f.read(100).decode('utf-8') except Exception as err: logger.warning("_update_public_ip failed: {}".format(err)) def update_bitcoin_public_port(self): try: _public_bitcoin_port = self.bitcoin_config["DEFAULT"]["port"] except KeyError: if self.chain.val == "test": _public_bitcoin_port = self.currency["testnet_port"] else: _public_bitcoin_port = self.currency["mainnet_port"] self.public_bitcoin_port.val = _public_bitcoin_port def check_public_ip_bitcoin_port(self): if port_check(self.public_ip.val, self.public_bitcoin_port.val, timeout=2.0): self.public_bitcoin_port_status.val = True self.public_bitcoin_port_status.txt = "" self.public_ip.style = "green" self.public_bitcoin_port.style = "green" else: self.public_bitcoin_port_status.val = False self.public_bitcoin_port_status.txt = "not reachable" self.public_bitcoin_port_status.style = "red" self.public_ip.style = "red" self.public_bitcoin_port.style = "red" def check_public_ip_lnd_port(self): if not self.lnd_external.val: return try: _public_lnd_port = int(self.lnd_external.val.split(":")[1]) if _public_lnd_port: if port_check(self.public_ip.val, _public_lnd_port, timeout=2.0): self.public_ip_lnd_port_status.val = True self.public_ip_lnd_port_status.txt = "" else: self.public_ip_lnd_port_status.val = False self.public_ip_lnd_port_status.txt = "not reachable" self.public_ip_lnd_port_status.style = "red" except IndexError as err: logger.warning("Error: {}".format(err)) def update(self): """update Metrics directly or call helper methods""" pass # self.update_load() # self.update_uptime() # self.update_cpu_temp() # self.update_memory() # self.update_storage() # self.update_ip_network_data() # self.update_network() # # self.update_bitcoin_dir() # self.read_bitcoin_config() # # self.update_chain() # # self.update_bitcoin_binaries() # self.check_bitcoind_is_running() # self.update_bitcoin_daemon_version() # self.update_bitcoin_data() # self.update_lnd_dirs() # self.read_lnd_config() # self.check_lnd_is_running() # self.update_lnd_wallet_is_locked() # self.update_lnd_alias() # self.update_lnd_data() # # self.update_public_ip() # self.update_bitcoin_public_port() # self.check_public_ip_lnd_port() # self.check_public_ip_bitcoin_port() def display(self): logo0 = _yellow(" ") logo1 = _yellow(" ,/ ") logo2 = _yellow(" ,'/ ") logo3 = _yellow(" ,' / ") logo4 = _yellow(" ,' /_____, ") logo5 = _yellow(" .'____ ,' ") logo6 = _yellow(" / ,' ") logo7 = _yellow(" / ,' ") logo8 = _yellow(" /,' ") logo9 = _yellow(" /' ") if self.lnd_is_running: if self.lnd_wallet_is_locked: lnd_info = Metric("Running", style="yellow") else: lnd_info = self.lnd_version else: lnd_info = Metric("Not Running", style="red") line9 = "LND {}".format(lnd_info) if self.lnd_base_msg.val and self.lnd_channel_msg.val: line9 = "{} {}\n {}".format(line9, self.lnd_base_msg, self.lnd_channel_msg) elif self.lnd_base_msg.val: line9 = "{} {}".format(line9, self.lnd_base_msg) elif self.lnd_channel_msg.val: line9 = "{} {}".format(line9, self.lnd_channel_msg) if not (self.lnd_channels_online.val and self.lnd_channels_total.val): pass else: if self.lnd_channels_online.val <= self.lnd_channels_total.val: self.lnd_channels_online.style = "yellow" self.lnd_channels_total.style = "yellow" elif self.lnd_channels_online.val == self.lnd_channels_total.val: self.lnd_channels_online.style = "green" self.lnd_channels_total.style = "green" else: self.lnd_channels_online.style = "red" self.lnd_channels_total.style = "red" lines = [ logo0, logo0 + "{} {} {}".format(self.name, self.version, self.lnd_alias), logo0 + "{} {} {}".format(self.network, "Fullnode + Lightning Network", self.tor_active), logo1 + _yellow("-------------------------------------------"), logo2 + "{} {}, {}, {} {} {}".format("load average:", self.load_one, self.load_five, self.load_fifteen, "CPU:", self.cpu_temp), logo3 + "{} {} / {} {} {} ({})".format("Free Mem:", self.memory_avail, self.memory_total, "Free HDD:", self.hdd_free_abs, self.hdd_free), logo4 + "{}{} ▼{} ▲{}".format("ssh admin@", self.local_ip, self.network_rx, self.network_tx), logo5, logo6 + "{} {} {} {} {} ({})".format(self.network, self.bitcoin_version, self.chain, "Sync", self.sync_status, self.sync_percentage), logo7 + "{} {}:{} {}".format("Public", self.public_ip, self.public_bitcoin_port, self.public_bitcoin_port_status), logo8 + "{} {} {}".format("", "", ""), logo9 + line9, logo0 + "Wallet {} sat {}/{} Chan {} sat".format(self.lnd_wallet_balance, self.lnd_channels_online, self.lnd_channels_total, self.lnd_channel_balance), logo0, "{} {}".format(self.lnd_external, self.public_ip_lnd_port_status) ] if self.bitcoin_log_msgs: lines.append(_yellow("Last lines of: ") + _red("bitcoin/debug.log")) for msg in self.bitcoin_log_msgs: if len(msg) <= 60: lines.append(msg) else: lines.append(msg[0:57] + "...") if len(self.bitcoin_local_adresses) == 1: lines.append("\nAdditional Public Address (e.g. IPv6)") lines.append("* {}".format(self.bitcoin_local_adresses[0])) elif len(self.bitcoin_local_adresses) >= 1: lines.append("\nAdditional Public Addresses (e.g. IPv6) only showing first") lines.append("* {}".format(self.bitcoin_local_adresses[0])) for line in lines: print(line) # def update_and_display(self): # self.update() # clear() # self.display() def main(): setup_logging() usage = "usage: %prog [Options]" parser = OptionParser(usage=usage, version="%prog {}".format(BOARD_VERSION)) parser.add_option("-H", "--host", dest="host", type="string", default="localhost", help="Host to listen on (default localhost)") parser.add_option("-P", "--port", dest="port", type="int", default="8000", help="Port to listen on (default 8000)") parser.add_option("-c", "--crypto-currency", dest="crypto_currency", type="string", default="bitcoin", help="Currency/Network to report on (default bitcoin)") parser.add_option("-t", "--timeout", dest="timeout", type="int", default=TIMEOUT, help="how long to wait for data to be collected (default {} sec)".format(TIMEOUT)) parser.add_option("-r", "--refresh", dest="refresh", type="int", default=5, help="interval to refresh data when looping (default 5 sec)") parser.add_option("--interface", dest="interface", type="string", default=IF_NAME, help="network interface to report on (default {})".format(IF_NAME)) options, args = parser.parse_args() crypto_currency = options.crypto_currency.lower() if crypto_currency not in list(CRYPTO_CURRENCIES.keys()): raise ValueError("Unexpected Crypto Currency given: {}".format(options.crypto_currency)) logger.info("Starting infoBlitz...") board = Dashboard(crypto_currency) board.timeout = 120 board.interface = options.interface board.name = Metric(BOARD_NAME, style="yellow") board.version = Metric(BOARD_VERSION, style="yellow") # use a threading.Lock() to ensure access to the same data from different threads board_lock = threading.Lock() dashboard_updater_thread = DashboardUpdater(board=board, board_lock=board_lock, interval=options.refresh) dashboard_printer_thread = DashboardPrinter(board=board, board_lock=board_lock, interval=options.refresh + 10) web_server_thread = ThreadedHTTPServer(options.host, options.port, board, board_lock, name="Web_Server") logger.info("Starting Dashboard Updater") dashboard_updater_thread.start() logger.info("Starting Dashboard Printer") dashboard_printer_thread.start() logger.info("Starting Web Server: http://{}:{}".format(options.host, options.port)) web_server_thread.start() # for info/debug only logger.debug("Threads: [{}]".format("; ".join([t.getName() for t in threading.enumerate()]))) try: while True: # run in loop that can be interrupted with CTRL+c time.sleep(0.2) # ToDO check.. not quite sure.. except KeyboardInterrupt: logger.debug("Stopping server loop") web_server_thread.stop() sys.exit(0) if __name__ == "__main__": main()