commit fa3a3f0eb11eec7d5af69148f1fc1deff0f6d9bd
Author: Damian Johnson <atagar(a)torproject.org>
Date: Tue Mar 8 09:40:12 2016 -0800
Move panels into their own module
Now that we're done overhauling the panels lets move them into their own
module. They've all had the same naming convention ('foo_panel.py') so this
just makes the grouping more explicit.
---
nyx/__init__.py | 5 -
nyx/config_panel.py | 357 -----------------------
nyx/connection_panel.py | 706 ---------------------------------------------
nyx/controller.py | 25 +-
nyx/graph_panel.py | 753 ------------------------------------------------
nyx/header_panel.py | 496 -------------------------------
nyx/log_panel.py | 454 -----------------------------
nyx/menu/actions.py | 8 +-
nyx/panel/__init__.py | 11 +
nyx/panel/config.py | 357 +++++++++++++++++++++++
nyx/panel/connection.py | 706 +++++++++++++++++++++++++++++++++++++++++++++
nyx/panel/graph.py | 753 ++++++++++++++++++++++++++++++++++++++++++++++++
nyx/panel/header.py | 496 +++++++++++++++++++++++++++++++
nyx/panel/log.py | 454 +++++++++++++++++++++++++++++
nyx/panel/torrc.py | 171 +++++++++++
nyx/torrc_panel.py | 171 -----------
nyx/util/log.py | 2 +-
setup.py | 2 +-
18 files changed, 2967 insertions(+), 2960 deletions(-)
diff --git a/nyx/__init__.py b/nyx/__init__.py
index 4d58435..25da9dd 100644
--- a/nyx/__init__.py
+++ b/nyx/__init__.py
@@ -14,14 +14,9 @@ __license__ = 'GPLv3'
__all__ = [
'arguments',
- 'config_panel',
- 'connection_panel',
'controller',
- 'header_panel',
- 'log_panel',
'popups',
'starter',
- 'torrc_panel',
]
diff --git a/nyx/config_panel.py b/nyx/config_panel.py
deleted file mode 100644
index 2352fe7..0000000
--- a/nyx/config_panel.py
+++ /dev/null
@@ -1,357 +0,0 @@
-"""
-Panel presenting the configuration state for tor or nyx. Options can be edited
-and the resulting configuration files saved.
-"""
-
-import curses
-import os
-
-import nyx.controller
-import nyx.popups
-
-import stem.control
-import stem.manual
-
-from nyx.util import DATA_DIR, panel, tor_controller, ui_tools
-
-from stem.util import conf, enum, log, str_tools
-
-SortAttr = enum.Enum('NAME', 'VALUE', 'VALUE_TYPE', 'CATEGORY', 'USAGE', 'SUMMARY', 'DESCRIPTION', 'MAN_PAGE_ENTRY', 'IS_SET')
-
-DETAILS_HEIGHT = 8
-NAME_WIDTH = 25
-VALUE_WIDTH = 15
-
-
-def conf_handler(key, value):
- if key == 'features.config.order':
- return conf.parse_enum_csv(key, value[0], SortAttr, 3)
-
-
-CONFIG = conf.config_dict('nyx', {
- 'attr.config.category_color': {},
- 'attr.config.sort_color': {},
- 'features.config.order': [SortAttr.MAN_PAGE_ENTRY, SortAttr.NAME, SortAttr.IS_SET],
- 'features.config.state.showPrivateOptions': False,
- 'features.config.state.showVirtualOptions': False,
-}, conf_handler)
-
-
-class ConfigEntry(object):
- """
- Configuration option presented in the panel.
-
- :var str name: name of the configuration option
- :var str value_type: type of value
- :var stem.manual.ConfigOption manual: manual information about the option
- """
-
- def __init__(self, name, value_type, manual):
- self.name = name
- self.value_type = value_type
- self.manual = manual.config_options.get(name, stem.manual.ConfigOption(name))
- self._index = manual.config_options.keys().index(name) if name in manual.config_options else 99999
-
- def value(self):
- """
- Provides the value of this configuration option.
-
- :returns: **str** representation of the current config value
- """
-
- values = tor_controller().get_conf(self.name, [], True)
-
- if not values:
- return '<none>'
- elif self.value_type == 'Boolean' and values[0] in ('0', '1'):
- return 'False' if values[0] == '0' else 'True'
- elif self.value_type == 'DataSize' and values[0].isdigit():
- return str_tools.size_label(int(values[0]))
- elif self.value_type == 'TimeInterval' and values[0].isdigit():
- return str_tools.time_label(int(values[0]), is_long = True)
- else:
- return ', '.join(values)
-
- def is_set(self):
- """
- Checks if the configuration option has a custom value.
-
- :returns: **True** if the option has a custom value, **False** otherwise
- """
-
- return tor_controller().is_set(self.name, False)
-
- def sort_value(self, attr):
- """
- Provides a heuristic for sorting by a given value.
-
- :param SortAttr attr: sort attribute to provide a heuristic for
-
- :returns: comparable value for sorting
- """
-
- if attr == SortAttr.CATEGORY:
- return self.manual.category
- elif attr == SortAttr.NAME:
- return self.name
- elif attr == SortAttr.VALUE:
- return self.value()
- elif attr == SortAttr.VALUE_TYPE:
- return self.value_type
- elif attr == SortAttr.USAGE:
- return self.manual.usage
- elif attr == SortAttr.SUMMARY:
- return self.manual.summary
- elif attr == SortAttr.DESCRIPTION:
- return self.manual.description
- elif attr == SortAttr.MAN_PAGE_ENTRY:
- return self._index
- elif attr == SortAttr.IS_SET:
- return not self.is_set()
-
-
-class ConfigPanel(panel.Panel):
- """
- Editor for tor's configuration.
- """
-
- def __init__(self, stdscr):
- panel.Panel.__init__(self, stdscr, 'configuration', 0)
-
- self._contents = []
- self._scroller = ui_tools.Scroller(True)
- self._sort_order = CONFIG['features.config.order']
- self._show_all = False # show all options, or just the important ones
-
- cached_manual_path = os.path.join(DATA_DIR, 'manual')
-
- if os.path.exists(cached_manual_path):
- manual = stem.manual.Manual.from_cache(cached_manual_path)
- else:
- try:
- manual = stem.manual.Manual.from_man()
-
- try:
- manual.save(cached_manual_path)
- except IOError as exc:
- log.debug("Unable to cache manual information to '%s'. This is fine, but means starting Nyx takes a little longer than usual: " % (cached_manual_path, exc))
- except IOError as exc:
- log.debug("Unable to use 'man tor' to get information about config options (%s), using bundled information instead" % exc)
- manual = stem.manual.Manual.from_cache()
-
- try:
- for line in tor_controller().get_info('config/names').splitlines():
- # Lines of the form "<option> <type>[ <documentation>]". Documentation
- # was apparently only in old tor versions like 0.2.1.25.
-
- if ' ' not in line:
- continue
-
- line_comp = line.split()
- name, value_type = line_comp[0], line_comp[1]
-
- # skips private and virtual entries if not configured to show them
-
- if name.startswith('__') and not CONFIG['features.config.state.showPrivateOptions']:
- continue
- elif value_type == 'Virtual' and not CONFIG['features.config.state.showVirtualOptions']:
- continue
-
- self._contents.append(ConfigEntry(name, value_type, manual))
-
- self._contents = sorted(self._contents, key = lambda entry: [entry.sort_value(field) for field in self._sort_order])
- except stem.ControllerError as exc:
- log.warn('Unable to determine the configuration options tor supports: %s' % exc)
-
- def show_sort_dialog(self):
- """
- Provides the dialog for sorting our configuration options.
- """
-
- sort_colors = dict([(attr, CONFIG['attr.config.sort_color'].get(attr, 'white')) for attr in SortAttr])
- results = nyx.popups.show_sort_dialog('Config Option Ordering:', SortAttr, self._sort_order, sort_colors)
-
- if results:
- self._sort_order = results
- self._contents = sorted(self._contents, key = lambda entry: [entry.sort_value(field) for field in self._sort_order])
-
- def show_write_dialog(self):
- """
- Confirmation dialog for saving tor's configuration.
- """
-
- selection, controller = 1, tor_controller()
- config_text = controller.get_info('config-text', None)
- config_lines = config_text.splitlines() if config_text else []
-
- with nyx.popups.popup_window(len(config_lines) + 2) as (popup, width, height):
- if not popup or height <= 2:
- return
-
- while True:
- height, width = popup.get_preferred_size() # allow us to be resized
- popup.win.erase()
-
- for i, full_line in enumerate(config_lines):
- line = str_tools.crop(full_line, width - 2)
- option, arg = line.split(' ', 1) if ' ' in line else (line, '')
-
- popup.addstr(i + 1, 1, option, curses.A_BOLD, 'green')
- popup.addstr(i + 1, len(option) + 2, arg, curses.A_BOLD, 'cyan')
-
- x = width - 16
-
- for i, option in enumerate(['Save', 'Cancel']):
- x = popup.addstr(height - 2, x, '[')
- x = popup.addstr(height - 2, x, option, curses.A_BOLD, curses.A_STANDOUT if i == selection else curses.A_NORMAL)
- x = popup.addstr(height - 2, x, '] ')
-
- popup.win.box()
- popup.addstr(0, 0, 'Torrc to save:', curses.A_STANDOUT)
- popup.win.refresh()
-
- key = nyx.controller.get_controller().key_input()
-
- if key.match('left'):
- selection = max(0, selection - 1)
- elif key.match('right'):
- selection = min(1, selection + 1)
- elif key.is_selection():
- if selection == 0:
- try:
- controller.save_conf()
- nyx.popups.show_msg('Saved configuration to %s' % controller.get_info('config-file', '<unknown>'), 2)
- except IOError as exc:
- nyx.popups.show_msg('Unable to save configuration (%s)' % exc.strerror, 2)
-
- break
- elif key.match('esc'):
- break # esc - cancel
-
- def handle_key(self, key):
- if key.is_scroll():
- page_height = self.get_preferred_size()[0] - DETAILS_HEIGHT
- is_changed = self._scroller.handle_key(key, self._get_config_options(), page_height)
-
- if is_changed:
- self.redraw(True)
- elif key.is_selection():
- selection = self._scroller.get_cursor_selection(self._get_config_options())
- initial_value = selection.value() if selection.is_set() else ''
- new_value = nyx.popups.input_prompt('%s Value (esc to cancel): ' % selection.name, initial_value)
-
- if new_value != initial_value:
- try:
- if selection.value_type == 'Boolean':
- # if the value's a boolean then allow for 'true' and 'false' inputs
-
- if new_value.lower() == 'true':
- new_value = '1'
- elif new_value.lower() == 'false':
- new_value = '0'
- elif selection.value_type == 'LineList':
- new_value = new_value.split(',') # set_conf accepts list inputs
-
- tor_controller().set_conf(selection.name, new_value)
- self.redraw(True)
- except Exception as exc:
- nyx.popups.show_msg('%s (press any key)' % exc)
- elif key.match('a'):
- self._show_all = not self._show_all
- self.redraw(True)
- elif key.match('s'):
- self.show_sort_dialog()
- elif key.match('w'):
- self.show_write_dialog()
- else:
- return False
-
- return True
-
- def get_help(self):
- return [
- ('up arrow', 'scroll up a line', None),
- ('down arrow', 'scroll down a line', None),
- ('page up', 'scroll up a page', None),
- ('page down', 'scroll down a page', None),
- ('enter', 'edit configuration option', None),
- ('w', 'write torrc', None),
- ('a', 'toggle filtering', None),
- ('s', 'sort ordering', None),
- ]
-
- def draw(self, width, height):
- contents = self._get_config_options()
- selection = self._scroller.get_cursor_selection(contents)
- scroll_location = self._scroller.get_scroll_location(contents, height - DETAILS_HEIGHT)
- is_scrollbar_visible = len(contents) > height - DETAILS_HEIGHT
-
- if selection is not None:
- self._draw_selection_details(selection, width)
-
- if self.is_title_visible():
- hidden_msg = "press 'a' to hide most options" if self._show_all else "press 'a' to show all options"
- self.addstr(0, 0, 'Tor Configuration (%s):' % hidden_msg, curses.A_STANDOUT)
-
- scroll_offset = 1
-
- if is_scrollbar_visible:
- scroll_offset = 3
- self.add_scroll_bar(scroll_location, scroll_location + height - DETAILS_HEIGHT, len(contents), DETAILS_HEIGHT)
-
- if selection is not None:
- self.addch(DETAILS_HEIGHT - 1, 1, curses.ACS_TTEE)
-
- # Description column can grow up to eighty characters. After that any extra
- # space goes to the value.
-
- description_width = max(0, width - scroll_offset - NAME_WIDTH - VALUE_WIDTH - 2)
-
- if description_width > 80:
- value_width = VALUE_WIDTH + (description_width - 80)
- description_width = 80
- else:
- value_width = VALUE_WIDTH
-
- for i, entry in enumerate(contents[scroll_location:]):
- attr = nyx.util.ui_tools.get_color(CONFIG['attr.config.category_color'].get(entry.manual.category, 'white'))
- attr |= curses.A_BOLD if entry.is_set() else curses.A_NORMAL
- attr |= curses.A_STANDOUT if entry == selection else curses.A_NORMAL
-
- option_label = str_tools.crop(entry.name, NAME_WIDTH).ljust(NAME_WIDTH + 1)
- value_label = str_tools.crop(entry.value(), value_width).ljust(value_width + 1)
- summary_label = str_tools.crop(entry.manual.summary, description_width).ljust(description_width)
-
- self.addstr(DETAILS_HEIGHT + i, scroll_offset, option_label + value_label + summary_label, attr)
-
- if DETAILS_HEIGHT + i >= height:
- break
-
- def _get_config_options(self):
- return self._contents if self._show_all else filter(lambda entry: stem.manual.is_important(entry.name) or entry.is_set(), self._contents)
-
- def _draw_selection_details(self, selection, width):
- """
- Shows details of the currently selected option.
- """
-
- description = 'Description: %s' % (selection.manual.description)
- attr = ', '.join(('custom' if selection.is_set() else 'default', selection.value_type, 'usage: %s' % selection.manual.usage))
- selected_color = CONFIG['attr.config.category_color'].get(selection.manual.category, 'white')
- ui_tools.draw_box(self, 0, 0, width, DETAILS_HEIGHT)
-
- self.addstr(1, 2, '%s (%s Option)' % (selection.name, selection.manual.category), curses.A_BOLD, selected_color)
- self.addstr(2, 2, 'Value: %s (%s)' % (selection.value(), str_tools.crop(attr, width - len(selection.value()) - 13)), curses.A_BOLD, selected_color)
-
- for i in range(DETAILS_HEIGHT - 4):
- if not description:
- break # done writing description
-
- line, description = description.split('\n', 1) if '\n' in description else (description, '')
-
- if i < DETAILS_HEIGHT - 5:
- line, remainder = str_tools.crop(line, width - 3, 4, 4, str_tools.Ending.HYPHEN, True)
- description = ' ' + remainder.strip() + description
- self.addstr(3 + i, 2, line, curses.A_BOLD, selected_color)
- else:
- self.addstr(3 + i, 2, str_tools.crop(line, width - 3, 4, 4), curses.A_BOLD, selected_color)
diff --git a/nyx/connection_panel.py b/nyx/connection_panel.py
deleted file mode 100644
index e28f531..0000000
--- a/nyx/connection_panel.py
+++ /dev/null
@@ -1,706 +0,0 @@
-"""
-Listing of the currently established connections tor has made.
-"""
-
-import re
-import time
-import collections
-import curses
-import itertools
-import threading
-
-import nyx.popups
-import nyx.util.tracker
-import nyx.util.ui_tools
-
-from nyx.util import panel, tor_controller, ui_tools
-
-from stem.control import Listener
-from stem.util import datetime_to_unix, conf, connection, enum, str_tools
-
-try:
- # added in python 3.2
- from functools import lru_cache
-except ImportError:
- from stem.util.lru_cache import lru_cache
-
-# height of the detail panel content, not counting top and bottom border
-
-DETAILS_HEIGHT = 7
-
-EXIT_USAGE_WIDTH = 15
-UPDATE_RATE = 5 # rate in seconds at which we refresh
-
-# cached information from our last _update() call
-
-LAST_RETRIEVED_HS_CONF = None
-LAST_RETRIEVED_CIRCUITS = None
-
-# Connection Categories:
-# Inbound Relay connection, coming to us.
-# Outbound Relay connection, leaving us.
-# Exit Outbound relay connection leaving the Tor network.
-# Hidden Connections to a hidden service we're providing.
-# Socks Socks connections for applications using Tor.
-# Circuit Circuits our tor client has created.
-# Directory Fetching tor consensus information.
-# Control Tor controller (nyx, vidalia, etc).
-
-Category = enum.Enum('INBOUND', 'OUTBOUND', 'EXIT', 'HIDDEN', 'SOCKS', 'CIRCUIT', 'DIRECTORY', 'CONTROL')
-SortAttr = enum.Enum('CATEGORY', 'UPTIME', 'IP_ADDRESS', 'PORT', 'FINGERPRINT', 'NICKNAME', 'COUNTRY')
-LineType = enum.Enum('CONNECTION', 'CIRCUIT_HEADER', 'CIRCUIT')
-
-Line = collections.namedtuple('Line', [
- 'entry',
- 'line_type',
- 'connection',
- 'circuit',
- 'fingerprint',
- 'nickname',
- 'locale',
-])
-
-
-def conf_handler(key, value):
- if key == 'features.connection.order':
- return conf.parse_enum_csv(key, value[0], SortAttr, 3)
-
-
-CONFIG = conf.config_dict('nyx', {
- 'attr.connection.category_color': {},
- 'attr.connection.sort_color': {},
- 'features.connection.resolveApps': True,
- 'features.connection.order': [SortAttr.CATEGORY, SortAttr.IP_ADDRESS, SortAttr.UPTIME],
- 'features.connection.showIps': True,
-}, conf_handler)
-
-
-class Entry(object):
- @staticmethod
- @lru_cache()
- def from_connection(connection):
- return ConnectionEntry(connection)
-
- @staticmethod
- @lru_cache()
- def from_circuit(circuit):
- return CircuitEntry(circuit)
-
- def get_lines(self):
- """
- Provides individual lines of connection information.
-
- :returns: **list** of **ConnectionLine** concerning this entry
- """
-
- raise NotImplementedError('should be implemented by subclasses')
-
- def get_type(self):
- """
- Provides our best guess at the type of connection this is.
-
- :returns: **Category** for the connection's type
- """
-
- raise NotImplementedError('should be implemented by subclasses')
-
- def is_private(self):
- """
- Checks if information about this endpoint should be scrubbed. Relaying
- etiquette (and wiretapping laws) say these are bad things to look at so
- DON'T CHANGE THIS UNLESS YOU HAVE A DAMN GOOD REASON!
-
- :returns: **bool** indicating if connection information is sensive or not
- """
-
- raise NotImplementedError('should be implemented by subclasses')
-
- def sort_value(self, attr):
- """
- Provides a heuristic for sorting by a given value.
-
- :param SortAttr attr: sort attribute to provide a heuristic for
-
- :returns: comparable value for sorting
- """
-
- line = self.get_lines()[0]
- at_end = 'z' * 20
-
- if attr == SortAttr.IP_ADDRESS:
- if self.is_private():
- return 255 ** 4 # orders at the end
-
- ip_value = 0
-
- for octet in line.connection.remote_address.split('.'):
- ip_value = ip_value * 255 + int(octet)
-
- return ip_value * 65536 + line.connection.remote_port
- elif attr == SortAttr.PORT:
- return line.connection.remote_port
- elif attr == SortAttr.FINGERPRINT:
- return line.fingerprint if line.fingerprint else at_end
- elif attr == SortAttr.NICKNAME:
- return line.nickname if line.nickname else at_end
- elif attr == SortAttr.CATEGORY:
- return Category.index_of(self.get_type())
- elif attr == SortAttr.UPTIME:
- return line.connection.start_time
- elif attr == SortAttr.COUNTRY:
- return line.locale if (line.locale and not self.is_private()) else at_end
- else:
- return ''
-
-
-class ConnectionEntry(Entry):
- def __init__(self, connection):
- self._connection = connection
-
- @lru_cache()
- def get_lines(self):
- fingerprint, nickname, locale = None, None, None
-
- if self.get_type() in (Category.OUTBOUND, Category.CIRCUIT, Category.DIRECTORY, Category.EXIT):
- fingerprint = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(self._connection.remote_address).get(self._connection.remote_port)
-
- if fingerprint:
- nickname = nyx.util.tracker.get_consensus_tracker().get_relay_nickname(fingerprint)
- locale = tor_controller().get_info('ip-to-country/%s' % self._connection.remote_address, None)
-
- return [Line(self, LineType.CONNECTION, self._connection, None, fingerprint, nickname, locale)]
-
- @lru_cache()
- def get_type(self):
- controller = tor_controller()
-
- if self._connection.local_port in controller.get_ports(Listener.OR, []):
- return Category.INBOUND
- elif self._connection.local_port in controller.get_ports(Listener.DIR, []):
- return Category.INBOUND
- elif self._connection.local_port in controller.get_ports(Listener.SOCKS, []):
- return Category.SOCKS
- elif self._connection.local_port in controller.get_ports(Listener.CONTROL, []):
- return Category.CONTROL
-
- if LAST_RETRIEVED_HS_CONF:
- for hs_config in LAST_RETRIEVED_HS_CONF.values():
- if self._connection.remote_port == hs_config['HiddenServicePort']:
- return Category.HIDDEN
-
- fingerprint = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(self._connection.remote_address).get(self._connection.remote_port)
-
- if fingerprint and LAST_RETRIEVED_CIRCUITS:
- for circ in LAST_RETRIEVED_CIRCUITS:
- if circ.path and len(circ.path) == 1 and circ.path[0][0] == fingerprint and circ.status == 'BUILT':
- return Category.DIRECTORY # one-hop circuit to retrieve directory information
- else:
- # not a known relay, might be an exit connection
-
- exit_policy = controller.get_exit_policy(None)
-
- if exit_policy and exit_policy.can_exit_to(self._connection.remote_address, self._connection.remote_port):
- return Category.EXIT
-
- return Category.OUTBOUND
-
- @lru_cache()
- def is_private(self):
- if not CONFIG['features.connection.showIps']:
- return True
-
- if self.get_type() == Category.INBOUND:
- controller = tor_controller()
-
- if controller.is_user_traffic_allowed().inbound:
- return len(nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(self._connection.remote_address)) == 0
- elif self.get_type() == Category.EXIT:
- # DNS connections exiting us aren't private (since they're hitting our
- # resolvers). Everything else is.
-
- return not (self._connection.remote_port == 53 and self._connection.protocol == 'udp')
-
- return False # for everything else this isn't a concern
-
-
-class CircuitEntry(Entry):
- def __init__(self, circuit):
- self._circuit = circuit
-
- @lru_cache()
- def get_lines(self):
- def line(fingerprint, line_type):
- address, port, nickname, locale = '0.0.0.0', 0, None, None
- consensus_tracker = nyx.util.tracker.get_consensus_tracker()
-
- if fingerprint is not None:
- address, port = consensus_tracker.get_relay_address(fingerprint, ('192.168.0.1', 0))
- nickname = consensus_tracker.get_relay_nickname(fingerprint)
- locale = tor_controller().get_info('ip-to-country/%s' % address, None)
-
- connection = nyx.util.tracker.Connection(datetime_to_unix(self._circuit.created), False, '127.0.0.1', 0, address, port, 'tcp', False)
- return Line(self, line_type, connection, self._circuit, fingerprint, nickname, locale)
-
- header_line = line(self._circuit.path[-1][0] if self._circuit.status == 'BUILT' else None, LineType.CIRCUIT_HEADER)
- return [header_line] + [line(fp, LineType.CIRCUIT) for fp, _ in self._circuit.path]
-
- def get_type(self):
- return Category.CIRCUIT
-
- def is_private(self):
- return False
-
-
-class ConnectionPanel(panel.Panel, threading.Thread):
- """
- Listing of connections tor is making, with information correlated against
- the current consensus and other data sources.
- """
-
- def __init__(self, stdscr):
- panel.Panel.__init__(self, stdscr, 'connections', 0)
- threading.Thread.__init__(self)
- self.setDaemon(True)
-
- self._scroller = ui_tools.Scroller(True)
- self._entries = [] # last fetched display entries
- self._show_details = False # presents the details panel if true
- self._sort_order = CONFIG['features.connection.order']
-
- self._last_resource_fetch = -1 # timestamp of the last ConnectionResolver results used
-
- self._pause_condition = threading.Condition()
- self._halt = False # terminates thread if true
-
- # Tracks exiting port and client country statistics
-
- self._client_locale_usage = {}
- self._exit_port_usage = {}
- self._counted_connections = set()
-
- # If we're a bridge and been running over a day then prepopulates with the
- # last day's clients.
-
- bridge_clients = tor_controller().get_info('status/clients-seen', None)
-
- if bridge_clients:
- # Response has a couple arguments...
- # TimeStarted="2011-08-17 15:50:49" CountrySummary=us=16,de=8,uk=8
-
- country_summary = None
-
- for line in bridge_clients.split():
- if line.startswith('CountrySummary='):
- country_summary = line[15:]
- break
-
- if country_summary:
- for entry in country_summary.split(','):
- if re.match('^..=[0-9]+$', entry):
- locale, count = entry.split('=', 1)
- self._client_locale_usage[locale] = int(count)
-
- def show_sort_dialog(self):
- """
- Provides a dialog for sorting our connections.
- """
-
- sort_colors = dict([(attr, CONFIG['attr.connection.sort_color'].get(attr, 'white')) for attr in SortAttr])
- results = nyx.popups.show_sort_dialog('Connection Ordering:', SortAttr, self._sort_order, sort_colors)
-
- if results:
- self._sort_order = results
- self._entries = sorted(self._entries, key = lambda entry: [entry.sort_value(attr) for attr in self._sort_order])
-
- def handle_key(self, key):
- user_traffic_allowed = tor_controller().is_user_traffic_allowed()
-
- if key.is_scroll():
- page_height = self.get_preferred_size()[0] - 1
-
- if self._show_details:
- page_height -= (DETAILS_HEIGHT + 1)
-
- lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in self._entries]))
- is_changed = self._scroller.handle_key(key, lines, page_height)
-
- if is_changed:
- self.redraw(True)
- elif key.is_selection():
- self._show_details = not self._show_details
- self.redraw(True)
- elif key.match('s'):
- self.show_sort_dialog()
- elif key.match('r'):
- connection_tracker = nyx.util.tracker.get_connection_tracker()
- options = ['auto'] + list(connection.Resolver) + list(nyx.util.tracker.CustomResolver)
-
- resolver = connection_tracker.get_custom_resolver()
- selected_index = 0 if resolver is None else options.index(resolver)
- selection = nyx.popups.show_menu('Connection Resolver:', options, selected_index)
-
- if selection != -1:
- connection_tracker.set_custom_resolver(None if selection == 0 else options[selection])
- elif key.match('d'):
- self.set_title_visible(False)
- self.redraw(True)
- entries = self._entries
-
- while True:
- lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in entries]))
- selection = self._scroller.get_cursor_selection(lines)
-
- if not selection:
- break
-
- def is_close_key(key):
- return key.is_selection() or key.match('d') or key.match('left') or key.match('right')
-
- color = CONFIG['attr.connection.category_color'].get(selection.entry.get_type(), 'white')
- key = nyx.popups.show_descriptor_popup(selection.fingerprint, color, self.max_x, is_close_key)
-
- if not key or key.is_selection() or key.match('d'):
- break # closes popup
- elif key.match('left'):
- self.handle_key(panel.KeyInput(curses.KEY_UP))
- elif key.match('right'):
- self.handle_key(panel.KeyInput(curses.KEY_DOWN))
-
- self.set_title_visible(True)
- self.redraw(True)
- elif key.match('c') and user_traffic_allowed.inbound:
- nyx.popups.show_count_dialog('Client Locales', self._client_locale_usage)
- elif key.match('e') and user_traffic_allowed.outbound:
- counts = {}
- key_width = max(map(len, self._exit_port_usage.keys()))
-
- for k, v in self._exit_port_usage.items():
- usage = connection.port_usage(k)
-
- if usage:
- k = k.ljust(key_width + 3) + usage.ljust(EXIT_USAGE_WIDTH)
-
- counts[k] = v
-
- nyx.popups.show_count_dialog('Exiting Port Usage', counts)
- else:
- return False
-
- return True
-
- def run(self):
- """
- Keeps connections listing updated, checking for new entries at a set rate.
- """
-
- last_ran = -1
-
- while not self._halt:
- if self.is_paused() or not tor_controller().is_alive() or (time.time() - last_ran) < UPDATE_RATE:
- with self._pause_condition:
- if not self._halt:
- self._pause_condition.wait(0.2)
-
- continue # done waiting, try again
-
- self._update()
- self.redraw(True)
-
- # If this is our first run then fill in our fingerprint tracker. This
- # requires fetching all the router status entries which takes a few
- # seconds, so best done when we're finished with the rest of the first
- # iteration to hide the lag.
-
- if last_ran == -1:
- nyx.util.tracker.get_consensus_tracker().update(tor_controller().get_network_statuses([]))
-
- last_ran = time.time()
-
- def get_help(self):
- resolver = nyx.util.tracker.get_connection_tracker().get_custom_resolver()
- user_traffic_allowed = tor_controller().is_user_traffic_allowed()
-
- options = [
- ('up arrow', 'scroll up a line', None),
- ('down arrow', 'scroll down a line', None),
- ('page up', 'scroll up a page', None),
- ('page down', 'scroll down a page', None),
- ('enter', 'show connection details', None),
- ('d', 'raw consensus descriptor', None),
- ('s', 'sort ordering', None),
- ('r', 'connection resolver', 'auto' if resolver is None else resolver),
- ]
-
- if user_traffic_allowed.inbound:
- options.append(('c', 'client locale usage summary', None))
-
- if user_traffic_allowed.outbound:
- options.append(('e', 'exit port usage summary', None))
-
- return options
-
- def draw(self, width, height):
- controller = tor_controller()
- entries = self._entries
-
- lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in entries]))
- selected = self._scroller.get_cursor_selection(lines)
-
- if self.is_paused():
- current_time = self.get_pause_time()
- elif not controller.is_alive():
- current_time = controller.connection_time()
- else:
- current_time = time.time()
-
- is_showing_details = self._show_details and selected
- details_offset = DETAILS_HEIGHT + 1 if is_showing_details else 0
-
- is_scrollbar_visible = len(lines) > height - details_offset - 1
- scroll_offset = 2 if is_scrollbar_visible else 0
- scroll_location = self._scroller.get_scroll_location(lines, height - details_offset - 1)
-
- if self.is_title_visible():
- self._draw_title(entries, self._show_details)
-
- if is_showing_details:
- self._draw_details(selected, width, is_scrollbar_visible)
-
- if is_scrollbar_visible:
- self.add_scroll_bar(scroll_location, scroll_location + height - details_offset - 1, len(lines), 1 + details_offset)
-
- for line_number in range(scroll_location, len(lines)):
- y = line_number + details_offset + 1 - scroll_location
- self._draw_line(scroll_offset, y, lines[line_number], lines[line_number] == selected, width - scroll_offset, current_time)
-
- if y >= height:
- break
-
- def _draw_title(self, entries, showing_details):
- """
- Panel title with the number of connections we presently have.
- """
-
- if showing_details:
- self.addstr(0, 0, 'Connection Details:', curses.A_STANDOUT)
- elif not entries:
- self.addstr(0, 0, 'Connections:', curses.A_STANDOUT)
- else:
- counts = collections.Counter([entry.get_type() for entry in entries])
- count_labels = ['%i %s' % (counts[category], category.lower()) for category in Category if counts[category]]
- self.addstr(0, 0, 'Connections (%s):' % ', '.join(count_labels), curses.A_STANDOUT)
-
- def _draw_details(self, selected, width, is_scrollbar_visible):
- """
- Shows detailed information about the selected connection.
- """
-
- attr = (CONFIG['attr.connection.category_color'].get(selected.entry.get_type(), 'white'), curses.A_BOLD)
-
- if selected.line_type == LineType.CIRCUIT_HEADER and selected.circuit.status != 'BUILT':
- self.addstr(1, 2, 'Building Circuit...', *attr)
- else:
- address = '<scrubbed>' if selected.entry.is_private() else selected.connection.remote_address
- self.addstr(1, 2, 'address: %s:%s' % (address, selected.connection.remote_port), *attr)
- self.addstr(2, 2, 'locale: %s' % ('??' if selected.entry.is_private() else (selected.locale if selected.locale else '??')), *attr)
-
- matches = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(selected.connection.remote_address)
-
- if not matches:
- self.addstr(3, 2, 'No consensus data found', *attr)
- elif len(matches) == 1 or selected.connection.remote_port in matches:
- controller = tor_controller()
- fingerprint = matches.values()[0] if len(matches) == 1 else matches[selected.connection.remote_port]
- router_status_entry = controller.get_network_status(fingerprint, None)
-
- self.addstr(2, 15, 'fingerprint: %s' % fingerprint, *attr)
-
- if router_status_entry:
- dir_port_label = 'dirport: %s' % router_status_entry.dir_port if router_status_entry.dir_port else ''
- self.addstr(3, 2, 'nickname: %-25s orport: %-10s %s' % (router_status_entry.nickname, router_status_entry.or_port, dir_port_label), *attr)
- self.addstr(4, 2, 'published: %s' % router_status_entry.published.strftime("%H:%M %m/%d/%Y"), *attr)
- self.addstr(5, 2, 'flags: %s' % ', '.join(router_status_entry.flags), *attr)
-
- server_descriptor = controller.get_server_descriptor(fingerprint, None)
-
- if server_descriptor:
- policy_label = server_descriptor.exit_policy.summary() if server_descriptor.exit_policy else 'unknown'
- self.addstr(6, 2, 'exit policy: %s' % policy_label, *attr)
- self.addstr(4, 38, 'os: %-14s version: %s' % (server_descriptor.operating_system, server_descriptor.tor_version), *attr)
-
- if server_descriptor.contact:
- self.addstr(7, 2, 'contact: %s' % server_descriptor.contact, *attr)
- else:
- self.addstr(3, 2, 'Multiple matches, possible fingerprints are:', *attr)
-
- for i, port in enumerate(sorted(matches.keys())):
- is_last_line, remaining_relays = i == 3, len(matches) - i
-
- if not is_last_line or remaining_relays == 1:
- self.addstr(4 + i, 2, '%i. or port: %-5s fingerprint: %s' % (i + 1, port, matches[port]), *attr)
- else:
- self.addstr(4 + i, 2, '... %i more' % remaining_relays, *attr)
-
- if is_last_line:
- break
-
- # draw the border, with a 'T' pipe if connecting with the scrollbar
-
- ui_tools.draw_box(self, 0, 0, width, DETAILS_HEIGHT + 2)
-
- if is_scrollbar_visible:
- self.addch(DETAILS_HEIGHT + 1, 1, curses.ACS_TTEE)
-
- def _draw_line(self, x, y, line, is_selected, width, current_time):
- attr = nyx.util.ui_tools.get_color(CONFIG['attr.connection.category_color'].get(line.entry.get_type(), 'white'))
- attr |= curses.A_STANDOUT if is_selected else curses.A_NORMAL
-
- self.addstr(y, x, ' ' * (width - x), attr)
-
- if line.line_type == LineType.CIRCUIT:
- if line.circuit.path[-1][0] == line.fingerprint:
- prefix = (ord(' '), curses.ACS_LLCORNER, curses.ACS_HLINE, ord(' '))
- else:
- prefix = (ord(' '), curses.ACS_VLINE, ord(' '), ord(' '))
-
- for char in prefix:
- x = self.addch(y, x, char)
- else:
- x += 1 # offset from edge
-
- self._draw_address_column(x, y, line, attr)
- self._draw_line_details(57, y, line, width - 57 - 20, attr)
- self._draw_right_column(width - 18, y, line, current_time, attr)
-
- def _draw_address_column(self, x, y, line, attr):
- src = tor_controller().get_info('address', line.connection.local_address)
- src += ':%s' % line.connection.local_port if line.line_type == LineType.CONNECTION else ''
-
- if line.line_type == LineType.CIRCUIT_HEADER and line.circuit.status != 'BUILT':
- dst = 'Building...'
- else:
- dst = '<scrubbed>' if line.entry.is_private() else line.connection.remote_address
- dst += ':%s' % line.connection.remote_port
-
- if line.entry.get_type() == Category.EXIT:
- purpose = connection.port_usage(line.connection.remote_port)
-
- if purpose:
- dst += ' (%s)' % str_tools.crop(purpose, 26 - len(dst) - 3)
- elif not tor_controller().is_geoip_unavailable() and not line.entry.is_private():
- dst += ' (%s)' % (line.locale if line.locale else '??')
-
- if line.entry.get_type() in (Category.INBOUND, Category.SOCKS, Category.CONTROL):
- dst, src = src, dst
-
- if line.line_type == LineType.CIRCUIT:
- self.addstr(y, x, dst, attr)
- else:
- self.addstr(y, x, '%-21s --> %-26s' % (src, dst), attr)
-
- def _draw_line_details(self, x, y, line, width, attr):
- if line.line_type == LineType.CIRCUIT_HEADER:
- comp = ['Purpose: %s' % line.circuit.purpose.capitalize(), ', Circuit ID: %s' % line.circuit.id]
- elif line.entry.get_type() in (Category.SOCKS, Category.HIDDEN, Category.CONTROL):
- try:
- port = line.connection.local_port if line.entry.get_type() == Category.HIDDEN else line.connection.remote_port
- process = nyx.util.tracker.get_port_usage_tracker().fetch(port)
- comp = ['%s (%s)' % (process.name, process.pid) if process.pid else process.name]
- except nyx.util.tracker.UnresolvedResult:
- comp = ['resolving...']
- except nyx.util.tracker.UnknownApplication:
- comp = ['UNKNOWN']
- else:
- comp = ['%-40s' % (line.fingerprint if line.fingerprint else 'UNKNOWN'), ' ' + (line.nickname if line.nickname else 'UNKNOWN')]
-
- for entry in comp:
- if width >= x + len(entry):
- x = self.addstr(y, x, entry, attr)
- else:
- return
-
- def _draw_right_column(self, x, y, line, current_time, attr):
- if line.line_type == LineType.CIRCUIT:
- circ_path = [fp for fp, _ in line.circuit.path]
- circ_index = circ_path.index(line.fingerprint)
-
- if circ_index == len(circ_path) - 1:
- placement_type = 'Exit' if line.circuit.status == 'BUILT' else 'Extending'
- elif circ_index == 0:
- placement_type = 'Guard'
- else:
- placement_type = 'Middle'
-
- self.addstr(y, x + 4, '%i / %s' % (circ_index + 1, placement_type), attr)
- else:
- x = self.addstr(y, x, '+' if line.connection.is_legacy else ' ', attr)
- x = self.addstr(y, x, '%5s' % str_tools.time_label(current_time - line.connection.start_time, 1), attr)
- x = self.addstr(y, x, ' (', attr)
- x = self.addstr(y, x, line.entry.get_type().upper(), attr | curses.A_BOLD)
- x = self.addstr(y, x, ')', attr)
-
- def stop(self):
- """
- Halts further resolutions and terminates the thread.
- """
-
- with self._pause_condition:
- self._halt = True
- self._pause_condition.notifyAll()
-
- def _update(self):
- """
- Fetches the newest resolved connections.
- """
-
- global LAST_RETRIEVED_CIRCUITS, LAST_RETRIEVED_HS_CONF
-
- controller = tor_controller()
- LAST_RETRIEVED_CIRCUITS = controller.get_circuits([])
- LAST_RETRIEVED_HS_CONF = controller.get_hidden_service_conf({})
-
- conn_resolver = nyx.util.tracker.get_connection_tracker()
- current_resolution_count = conn_resolver.run_counter()
-
- if not conn_resolver.is_alive():
- return # if we're not fetching connections then this is a no-op
- elif current_resolution_count == self._last_resource_fetch:
- return # no new connections to process
-
- new_entries = [Entry.from_connection(conn) for conn in conn_resolver.get_value()]
-
- for circ in LAST_RETRIEVED_CIRCUITS:
- # Skips established single-hop circuits (these are for directory
- # fetches, not client circuits)
-
- if not (circ.status == 'BUILT' and len(circ.path) == 1):
- new_entries.append(Entry.from_circuit(circ))
-
- # update stats for client and exit connections
-
- for entry in new_entries:
- line = entry.get_lines()[0]
-
- if entry.is_private() and line.connection not in self._counted_connections:
- if entry.get_type() == Category.INBOUND and line.locale:
- self._client_locale_usage[line.locale] = self._client_locale_usage.get(line.locale, 0) + 1
- elif entry.get_type() == Category.EXIT:
- self._exit_port_usage[line.connection.remote_port] = self._exit_port_usage.get(line.connection.remote_port, 0) + 1
-
- self._counted_connections.add(line.connection)
-
- self._entries = sorted(new_entries, key = lambda entry: [entry.sort_value(attr) for attr in self._sort_order])
- self._last_resource_fetch = current_resolution_count
-
- if CONFIG['features.connection.resolveApps']:
- local_ports, remote_ports = [], []
-
- for entry in new_entries:
- line = entry.get_lines()[0]
-
- if entry.get_type() in (Category.SOCKS, Category.CONTROL):
- local_ports.append(line.connection.remote_port)
- elif entry.get_type() == Category.HIDDEN:
- remote_ports.append(line.connection.local_port)
-
- nyx.util.tracker.get_port_usage_tracker().query(local_ports, remote_ports)
diff --git a/nyx/controller.py b/nyx/controller.py
index e143b49..318df4b 100644
--- a/nyx/controller.py
+++ b/nyx/controller.py
@@ -9,14 +9,15 @@ import threading
import nyx.menu.menu
import nyx.popups
-import nyx.header_panel
-import nyx.log_panel
-import nyx.config_panel
-import nyx.torrc_panel
-import nyx.graph_panel
-import nyx.connection_panel
import nyx.util.tracker
+import nyx.panel.config
+import nyx.panel.connection
+import nyx.panel.graph
+import nyx.panel.header
+import nyx.panel.log
+import nyx.panel.torrc
+
import stem
from stem.util import conf, log
@@ -102,29 +103,29 @@ class Controller:
self._screen = stdscr
self._sticky_panels = [
- nyx.header_panel.HeaderPanel(stdscr),
+ nyx.panel.header.HeaderPanel(stdscr),
LabelPanel(stdscr),
]
self._page_panels, first_page_panels = [], []
if CONFIG['features.panels.show.graph']:
- first_page_panels.append(nyx.graph_panel.GraphPanel(stdscr))
+ first_page_panels.append(nyx.panel.graph.GraphPanel(stdscr))
if CONFIG['features.panels.show.log']:
- first_page_panels.append(nyx.log_panel.LogPanel(stdscr))
+ first_page_panels.append(nyx.panel.log.LogPanel(stdscr))
if first_page_panels:
self._page_panels.append(first_page_panels)
if CONFIG['features.panels.show.connection']:
- self._page_panels.append([nyx.connection_panel.ConnectionPanel(stdscr)])
+ self._page_panels.append([nyx.panel.connection.ConnectionPanel(stdscr)])
if CONFIG['features.panels.show.config']:
- self._page_panels.append([nyx.config_panel.ConfigPanel(stdscr)])
+ self._page_panels.append([nyx.panel.config.ConfigPanel(stdscr)])
if CONFIG['features.panels.show.torrc']:
- self._page_panels.append([nyx.torrc_panel.TorrcPanel(stdscr)])
+ self._page_panels.append([nyx.panel.torrc.TorrcPanel(stdscr)])
self.quit_signal = False
self._page = 0
diff --git a/nyx/graph_panel.py b/nyx/graph_panel.py
deleted file mode 100644
index 086d04d..0000000
--- a/nyx/graph_panel.py
+++ /dev/null
@@ -1,753 +0,0 @@
-"""
-Graphs of tor related statistics. For example...
-
-Downloaded (0.0 B/sec): Uploaded (0.0 B/sec):
- 34 30
- * *
- ** * * * **
- * * * ** ** ** *** ** ** ** **
- ********* ****** ****** ********* ****** ******
- 0 ************ **************** 0 ************ ****************
- 25s 50 1m 1.6 2.0 25s 50 1m 1.6 2.0
-"""
-
-import collections
-import copy
-import curses
-import time
-
-import nyx.controller
-import nyx.popups
-import nyx.util.tracker
-
-from stem.control import EventType, Listener
-from stem.util import conf, enum, log, str_tools, system
-from nyx.util import join, msg, panel, tor_controller
-
-GraphStat = enum.Enum(('BANDWIDTH', 'bandwidth'), ('CONNECTIONS', 'connections'), ('SYSTEM_RESOURCES', 'resources'))
-Interval = enum.Enum(('EACH_SECOND', 'each second'), ('FIVE_SECONDS', '5 seconds'), ('THIRTY_SECONDS', '30 seconds'), ('MINUTELY', 'minutely'), ('FIFTEEN_MINUTE', '15 minute'), ('THIRTY_MINUTE', '30 minute'), ('HOURLY', 'hourly'), ('DAILY', 'daily'))
-Bounds = enum.Enum(('GLOBAL_MAX', 'global_max'), ('LOCAL_MAX', 'local_max'), ('TIGHT', 'tight'))
-
-DrawAttributes = collections.namedtuple('DrawAttributes', ('stat', 'subgraph_height', 'subgraph_width', 'interval', 'bounds_type', 'accounting'))
-
-INTERVAL_SECONDS = {
- Interval.EACH_SECOND: 1,
- Interval.FIVE_SECONDS: 5,
- Interval.THIRTY_SECONDS: 30,
- Interval.MINUTELY: 60,
- Interval.FIFTEEN_MINUTE: 900,
- Interval.THIRTY_MINUTE: 1800,
- Interval.HOURLY: 3600,
- Interval.DAILY: 86400,
-}
-
-PRIMARY_COLOR, SECONDARY_COLOR = 'green', 'cyan'
-
-ACCOUNTING_RATE = 5
-DEFAULT_CONTENT_HEIGHT = 4 # space needed for labeling above and below the graph
-WIDE_LABELING_GRAPH_COL = 50 # minimum graph columns to use wide spacing for x-axis labels
-COLLAPSE_WIDTH = 135 # width at which to move optional stats from the title to x-axis label
-
-
-def conf_handler(key, value):
- if key == 'features.graph.height':
- return max(1, value)
- elif key == 'features.graph.max_width':
- return max(1, value)
- elif key == 'features.graph.type':
- if value != 'none' and value not in GraphStat:
- log.warn("'%s' isn't a valid graph type, options are: none, %s" % (CONFIG['features.graph.type'], ', '.join(GraphStat)))
- return CONFIG['features.graph.type'] # keep the default
- elif key == 'features.graph.interval':
- if value not in Interval:
- log.warn("'%s' isn't a valid graphing interval, options are: %s" % (value, ', '.join(Interval)))
- return CONFIG['features.graph.interval'] # keep the default
- elif key == 'features.graph.bound':
- if value not in Bounds:
- log.warn("'%s' isn't a valid graph bounds, options are: %s" % (value, ', '.join(Bounds)))
- return CONFIG['features.graph.bound'] # keep the default
-
-
-CONFIG = conf.config_dict('nyx', {
- 'attr.hibernate_color': {},
- 'attr.graph.title': {},
- 'attr.graph.header.primary': {},
- 'attr.graph.header.secondary': {},
- 'features.graph.height': 7,
- 'features.graph.type': GraphStat.BANDWIDTH,
- 'features.graph.interval': Interval.EACH_SECOND,
- 'features.graph.bound': Bounds.LOCAL_MAX,
- 'features.graph.max_width': 300, # we need some sort of max size so we know how much graph data to retain
- 'features.panels.show.connection': True,
- 'features.graph.bw.transferInBytes': False,
- 'features.graph.bw.accounting.show': True,
-}, conf_handler)
-
-
-class GraphData(object):
- """
- Graphable statistical information.
-
- :var int latest_value: last value we recorded
- :var int total: sum of all values we've recorded
- :var int tick: number of events we've processed
- :var dict values: mapping of intervals to an array of samplings from newest to oldest
- :var dict max_value: mapping of intervals to the maximum value it has had
- """
-
- def __init__(self, clone = None, category = None, is_primary = True):
- if clone:
- self.latest_value = clone.latest_value
- self.total = clone.total
- self.tick = clone.tick
- self.values = copy.deepcopy(clone.values)
- self.max_value = dict(clone.max_value)
-
- self._category = clone._category
- self._is_primary = clone._is_primary
- self._in_process_value = dict(clone._in_process_value)
- else:
- self.latest_value = 0
- self.total = 0
- self.tick = 0
- self.values = dict([(i, CONFIG['features.graph.max_width'] * [0]) for i in Interval])
- self.max_value = dict([(i, 0) for i in Interval])
-
- self._category = category
- self._is_primary = is_primary
- self._in_process_value = dict([(i, 0) for i in Interval])
-
- def average(self):
- return self.total / max(1, self.tick)
-
- def update(self, new_value):
- self.latest_value = new_value
- self.total += new_value
- self.tick += 1
-
- for interval in Interval:
- interval_seconds = INTERVAL_SECONDS[interval]
- self._in_process_value[interval] += new_value
-
- if self.tick % interval_seconds == 0:
- new_entry = self._in_process_value[interval] / interval_seconds
- self.values[interval] = [new_entry] + self.values[interval][:-1]
- self.max_value[interval] = max(self.max_value[interval], new_entry)
- self._in_process_value[interval] = 0
-
- def header(self, width):
- """
- Provides the description above a subgraph.
-
- :param int width: maximum length of the header
-
- :returns: **str** with our graph header
- """
-
- return self._category._header(width, self._is_primary)
-
- def y_axis_label(self, value):
- """
- Provides the label we should display on our y-axis.
-
- :param int value: value being shown on the y-axis
-
- :returns: **str** with our y-axis label
- """
-
- return self._category._y_axis_label(value, self._is_primary)
-
-
-class GraphCategory(object):
- """
- Category for the graph. This maintains two subgraphs, updating them each
- second with updated stats.
-
- :var GraphData primary: first subgraph
- :var GraphData secondary: second subgraph
- :var float start_time: unix timestamp for when we started
- """
-
- def __init__(self, clone = None):
- if clone:
- self.primary = GraphData(clone.primary)
- self.secondary = GraphData(clone.secondary)
- self.start_time = clone.start_time
- self._title_stats = list(clone._title_stats)
- self._primary_header_stats = list(clone._primary_header_stats)
- self._secondary_header_stats = list(clone._secondary_header_stats)
- else:
- self.primary = GraphData(category = self, is_primary = True)
- self.secondary = GraphData(category = self, is_primary = False)
- self.start_time = time.time()
- self._title_stats = []
- self._primary_header_stats = []
- self._secondary_header_stats = []
-
- def stat_type(self):
- """
- Provides the GraphStat this graph is for.
-
- :returns: **GraphStat** of this graph
- """
-
- raise NotImplementedError('Should be implemented by subclasses')
-
- def title(self, width):
- """
- Provides a graph title that fits in the given width.
-
- :param int width: maximum length of the title
-
- :returns: **str** with our title
- """
-
- title = CONFIG['attr.graph.title'].get(self.stat_type(), '')
- title_stats = join(self._title_stats, ', ', width - len(title) - 4)
- return '%s (%s):' % (title, title_stats) if title_stats else title + ':'
-
- def bandwidth_event(self, event):
- """
- Called when it's time to process another event. All graphs use tor BW
- events to keep in sync with each other (this happens once per second).
- """
-
- pass
-
- def _header(self, is_primary, width):
- if is_primary:
- header = CONFIG['attr.graph.header.primary'].get(self.stat_type(), '')
- header_stats = self._primary_header_stats
- else:
- header = CONFIG['attr.graph.header.secondary'].get(self.stat_type(), '')
- header_stats = self._secondary_header_stats
-
- header_stats = join(header_stats, '', width - len(header) - 4)
- return '%s (%s):' % (header, header_stats) if header_stats else '%s:' % header
-
- def _y_axis_label(self, value, is_primary):
- return str(value)
-
-
-class BandwidthStats(GraphCategory):
- """
- Tracks tor's bandwidth usage.
- """
-
- def __init__(self, clone = None):
- GraphCategory.__init__(self, clone)
-
- if not clone:
- # fill in past bandwidth information
-
- controller = tor_controller()
- bw_entries, is_successful = controller.get_info('bw-event-cache', None), True
-
- if bw_entries:
- for entry in bw_entries.split():
- entry_comp = entry.split(',')
-
- if len(entry_comp) != 2 or not entry_comp[0].isdigit() or not entry_comp[1].isdigit():
- log.warn(msg('panel.graphing.bw_event_cache_malformed', response = bw_entries))
- is_successful = False
- break
-
- self.primary.update(int(entry_comp[0]))
- self.secondary.update(int(entry_comp[1]))
-
- if is_successful:
- log.info(msg('panel.graphing.prepopulation_successful', duration = str_tools.time_label(len(bw_entries.split()), is_long = True)))
-
- read_total = controller.get_info('traffic/read', None)
- write_total = controller.get_info('traffic/written', None)
- start_time = system.start_time(controller.get_pid(None))
-
- if read_total and write_total and start_time:
- self.primary.total = int(read_total)
- self.secondary.total = int(write_total)
- self.start_time = start_time
-
- def stat_type(self):
- return GraphStat.BANDWIDTH
-
- def _y_axis_label(self, value, is_primary):
- return _size_label(value, 0)
-
- def bandwidth_event(self, event):
- self.primary.update(event.read)
- self.secondary.update(event.written)
-
- self._primary_header_stats = [
- '%-14s' % ('%s/sec' % _size_label(self.primary.latest_value)),
- '- avg: %s/sec' % _size_label(self.primary.total / (time.time() - self.start_time)),
- ', total: %s' % _size_label(self.primary.total),
- ]
-
- self._secondary_header_stats = [
- '%-14s' % ('%s/sec' % _size_label(self.secondary.latest_value)),
- '- avg: %s/sec' % _size_label(self.secondary.total / (time.time() - self.start_time)),
- ', total: %s' % _size_label(self.secondary.total),
- ]
-
- controller = tor_controller()
-
- stats = []
- bw_rate = controller.get_effective_rate(None)
- bw_burst = controller.get_effective_rate(None, burst = True)
-
- if bw_rate and bw_burst:
- bw_rate_label = _size_label(bw_rate)
- bw_burst_label = _size_label(bw_burst)
-
- # if both are using rounded values then strip off the '.0' decimal
-
- if '.0' in bw_rate_label and '.0' in bw_burst_label:
- bw_rate_label = bw_rate_label.split('.', 1)[0]
- bw_burst_label = bw_burst_label.split('.', 1)[0]
-
- stats.append('limit: %s/s' % bw_rate_label)
- stats.append('burst: %s/s' % bw_burst_label)
-
- my_router_status_entry = controller.get_network_status(default = None)
- measured_bw = getattr(my_router_status_entry, 'bandwidth', None)
-
- if measured_bw:
- stats.append('measured: %s/s' % _size_label(measured_bw))
- else:
- my_server_descriptor = controller.get_server_descriptor(default = None)
- observed_bw = getattr(my_server_descriptor, 'observed_bandwidth', None)
-
- if observed_bw:
- stats.append('observed: %s/s' % _size_label(observed_bw))
-
- self._title_stats = stats
-
-
-class ConnectionStats(GraphCategory):
- """
- Tracks number of inbound and outbound connections.
- """
-
- def stat_type(self):
- return GraphStat.CONNECTIONS
-
- def bandwidth_event(self, event):
- inbound_count, outbound_count = 0, 0
-
- controller = tor_controller()
- or_ports = controller.get_ports(Listener.OR, [])
- dir_ports = controller.get_ports(Listener.DIR, [])
- control_ports = controller.get_ports(Listener.CONTROL, [])
-
- for entry in nyx.util.tracker.get_connection_tracker().get_value():
- if entry.local_port in or_ports or entry.local_port in dir_ports:
- inbound_count += 1
- elif entry.local_port in control_ports:
- pass # control connection
- else:
- outbound_count += 1
-
- self.primary.update(inbound_count)
- self.secondary.update(outbound_count)
-
- self._primary_header_stats = [str(self.primary.latest_value), ', avg: %s' % self.primary.average()]
- self._secondary_header_stats = [str(self.secondary.latest_value), ', avg: %s' % self.secondary.average()]
-
-
-class ResourceStats(GraphCategory):
- """
- Tracks cpu and memory usage of the tor process.
- """
-
- def stat_type(self):
- return GraphStat.SYSTEM_RESOURCES
-
- def _y_axis_label(self, value, is_primary):
- return '%i%%' % value if is_primary else str_tools.size_label(value)
-
- def bandwidth_event(self, event):
- resources = nyx.util.tracker.get_resource_tracker().get_value()
- self.primary.update(resources.cpu_sample * 100) # decimal percentage to whole numbers
- self.secondary.update(resources.memory_bytes)
-
- self._primary_header_stats = ['%0.1f%%' % self.primary.latest_value, ', avg: %0.1f%%' % self.primary.average()]
- self._secondary_header_stats = [str_tools.size_label(self.secondary.latest_value, 1), ', avg: %s' % str_tools.size_label(self.secondary.average(), 1)]
-
-
-class GraphPanel(panel.Panel):
- """
- Panel displaying graphical information of GraphCategory instances.
- """
-
- def __init__(self, stdscr):
- panel.Panel.__init__(self, stdscr, 'graph', 0)
-
- self._displayed_stat = None if CONFIG['features.graph.type'] == 'none' else CONFIG['features.graph.type']
- self._update_interval = CONFIG['features.graph.interval']
- self._bounds = CONFIG['features.graph.bound']
- self._graph_height = CONFIG['features.graph.height']
-
- self._accounting_stats = None
-
- self._stats = {
- GraphStat.BANDWIDTH: BandwidthStats(),
- GraphStat.SYSTEM_RESOURCES: ResourceStats(),
- }
-
- if CONFIG['features.panels.show.connection']:
- self._stats[GraphStat.CONNECTIONS] = ConnectionStats()
- elif self._displayed_stat == GraphStat.CONNECTIONS:
- log.warn("The connection graph is unavailble when you set 'features.panels.show.connection false'.")
- self._displayed_stat = GraphStat.BANDWIDTH
-
- self.set_pause_attr('_stats')
- self.set_pause_attr('_accounting_stats')
-
- controller = tor_controller()
- controller.add_event_listener(self._update_accounting, EventType.BW)
- controller.add_event_listener(self._update_stats, EventType.BW)
- controller.add_status_listener(lambda *args: self.redraw(True))
-
- @property
- def displayed_stat(self):
- return self._displayed_stat
-
- @displayed_stat.setter
- def displayed_stat(self, value):
- if value is not None and value not in self._stats.keys():
- raise ValueError("%s isn't a graphed statistic" % value)
-
- self._displayed_stat = value
-
- def stat_options(self):
- return self._stats.keys()
-
- @property
- def update_interval(self):
- return self._update_interval
-
- @update_interval.setter
- def update_interval(self, value):
- if value not in Interval:
- raise ValueError("%s isn't a valid graphing update interval" % value)
-
- self._update_interval = value
-
- @property
- def bounds_type(self):
- return self._bounds
-
- @bounds_type.setter
- def bounds_type(self, value):
- if value not in Bounds:
- raise ValueError("%s isn't a valid type of bounds" % value)
-
- self._bounds = value
-
- def get_height(self):
- """
- Provides the height of the content.
- """
-
- if not self.displayed_stat:
- return 0
-
- height = DEFAULT_CONTENT_HEIGHT + self._graph_height
-
- if self.displayed_stat == GraphStat.BANDWIDTH and self._accounting_stats:
- height += 3
-
- return height
-
- def set_graph_height(self, new_graph_height):
- self._graph_height = max(1, new_graph_height)
-
- def resize_graph(self):
- """
- Prompts for user input to resize the graph panel. Options include...
-
- * down arrow - grow graph
- * up arrow - shrink graph
- * enter / space - set size
- """
-
- control = nyx.controller.get_controller()
-
- with panel.CURSES_LOCK:
- try:
- while True:
- msg = 'press the down/up to resize the graph, and enter when done'
- control.set_msg(msg, curses.A_BOLD, True)
- curses.cbreak()
- key = control.key_input()
-
- if key.match('down'):
- # don't grow the graph if it's already consuming the whole display
- # (plus an extra line for the graph/log gap)
-
- max_height = self.parent.getmaxyx()[0] - self.top
- current_height = self.get_height()
-
- if current_height < max_height + 1:
- self.set_graph_height(self._graph_height + 1)
- elif key.match('up'):
- self.set_graph_height(self._graph_height - 1)
- elif key.is_selection():
- break
-
- control.redraw()
- finally:
- control.set_msg()
-
- def handle_key(self, key):
- if key.match('r'):
- self.resize_graph()
- elif key.match('b'):
- # uses the next boundary type
- self.bounds_type = Bounds.next(self.bounds_type)
- self.redraw(True)
- elif key.match('s'):
- # provides a menu to pick the graphed stats
-
- available_stats = sorted(self.stat_options())
- options = ['None'] + [stat.capitalize() for stat in available_stats]
- initial_selection = available_stats.index(self.displayed_stat) + 1 if self.displayed_stat else 0
-
- selection = nyx.popups.show_menu('Graphed Stats:', options, initial_selection)
-
- # applies new setting
-
- if selection == 0:
- self.displayed_stat = None
- elif selection != -1:
- self.displayed_stat = available_stats[selection - 1]
- elif key.match('i'):
- # provides menu to pick graph panel update interval
-
- selection = nyx.popups.show_menu('Update Interval:', list(Interval), list(Interval).index(self.update_interval))
-
- if selection != -1:
- self.update_interval = list(Interval)[selection]
- else:
- return False
-
- return True
-
- def get_help(self):
- return [
- ('r', 'resize graph', None),
- ('s', 'graphed stats', self.displayed_stat if self.displayed_stat else 'none'),
- ('b', 'graph bounds', self.bounds_type.replace('_', ' ')),
- ('i', 'graph update interval', self.update_interval),
- ]
-
- def draw(self, width, height):
- if not self.displayed_stat:
- return
-
- stat = self.get_attr('_stats')[self.displayed_stat]
-
- attr = DrawAttributes(
- stat = type(stat)(stat), # clone the GraphCategory
- subgraph_height = self._graph_height + 2, # graph rows + header + x-axis label
- subgraph_width = min(width / 2, CONFIG['features.graph.max_width']),
- interval = self.update_interval,
- bounds_type = self.bounds_type,
- accounting = self.get_attr('_accounting_stats'),
- )
-
- if self.is_title_visible():
- self.addstr(0, 0, attr.stat.title(width), curses.A_STANDOUT)
-
- self._draw_subgraph(attr, attr.stat.primary, 0, PRIMARY_COLOR)
- self._draw_subgraph(attr, attr.stat.secondary, attr.subgraph_width, SECONDARY_COLOR)
-
- if attr.stat.stat_type() == GraphStat.BANDWIDTH:
- if width <= COLLAPSE_WIDTH:
- self._draw_bandwidth_stats(attr, width)
-
- if attr.accounting:
- self._draw_accounting_stats(attr)
-
- def _draw_subgraph(self, attr, data, x, color):
- # Concering our subgraph colums, the y-axis label can be at most six
- # characters, with two spaces of padding on either side of the graph.
- # Starting with the smallest size, then possibly raise it after determing
- # the y_axis_labels.
-
- subgraph_columns = attr.subgraph_width - 8
- min_bound, max_bound = self._get_graph_bounds(attr, data, subgraph_columns)
-
- x_axis_labels = self._get_x_axis_labels(attr, subgraph_columns)
- y_axis_labels = self._get_y_axis_labels(attr, data, min_bound, max_bound)
- subgraph_columns = max(subgraph_columns, attr.subgraph_width - max([len(label) for label in y_axis_labels.values()]) - 2)
- axis_offset = max([len(label) for label in y_axis_labels.values()])
-
- self.addstr(1, x, data.header(attr.subgraph_width), curses.A_BOLD, color)
-
- for x_offset, label in x_axis_labels.items():
- self.addstr(attr.subgraph_height, x + x_offset + axis_offset, label, color)
-
- for y, label in y_axis_labels.items():
- self.addstr(y, x, label, color)
-
- for col in range(subgraph_columns):
- column_count = int(data.values[attr.interval][col]) - min_bound
- column_height = int(min(attr.subgraph_height - 2, (attr.subgraph_height - 2) * column_count / (max(1, max_bound) - min_bound)))
-
- for row in range(column_height):
- self.addstr(attr.subgraph_height - 1 - row, x + col + axis_offset + 1, ' ', curses.A_STANDOUT, color)
-
- def _get_graph_bounds(self, attr, data, subgraph_columns):
- """
- Provides the range the graph shows (ie, its minimum and maximum value).
- """
-
- min_bound, max_bound = 0, 0
- values = data.values[attr.interval][:subgraph_columns]
-
- if attr.bounds_type == Bounds.GLOBAL_MAX:
- max_bound = data.max_value[attr.interval]
- elif subgraph_columns > 0:
- max_bound = max(values) # local maxima
-
- if attr.bounds_type == Bounds.TIGHT and subgraph_columns > 0:
- min_bound = min(values)
-
- # if the max = min pick zero so we still display something
-
- if min_bound == max_bound:
- min_bound = 0
-
- return min_bound, max_bound
-
- def _get_y_axis_labels(self, attr, data, min_bound, max_bound):
- """
- Provides the labels for the y-axis. This is a mapping of the position it
- should be drawn at to its text.
- """
-
- y_axis_labels = {
- 2: data.y_axis_label(max_bound),
- attr.subgraph_height - 1: data.y_axis_label(min_bound),
- }
-
- ticks = (attr.subgraph_height - 5) / 2
-
- for i in range(ticks):
- row = attr.subgraph_height - (2 * i) - 5
-
- if attr.subgraph_height % 2 == 0 and i >= (ticks / 2):
- row -= 1 # make extra gap be in the middle when we're an even size
-
- val = (max_bound - min_bound) * (attr.subgraph_height - row - 3) / (attr.subgraph_height - 3)
-
- if val not in (min_bound, max_bound):
- y_axis_labels[row + 2] = data.y_axis_label(val)
-
- return y_axis_labels
-
- def _get_x_axis_labels(self, attr, subgraph_columns):
- """
- Provides the labels for the x-axis. We include the units for only its first
- value, then bump the precision for subsequent units. For example...
-
- 10s, 20, 30, 40, 50, 1m, 1.1, 1.3, 1.5
- """
-
- x_axis_labels = {}
-
- interval_sec = INTERVAL_SECONDS[attr.interval]
- interval_spacing = 10 if subgraph_columns >= WIDE_LABELING_GRAPH_COL else 5
- units_label, decimal_precision = None, 0
-
- for i in range((subgraph_columns - 4) / interval_spacing):
- x = (i + 1) * interval_spacing
- time_label = str_tools.time_label(x * interval_sec, decimal_precision)
-
- if not units_label:
- units_label = time_label[-1]
- elif units_label != time_label[-1]:
- # upped scale so also up precision of future measurements
- units_label = time_label[-1]
- decimal_precision += 1
- else:
- # if constrained on space then strips labeling since already provided
- time_label = time_label[:-1]
-
- x_axis_labels[x] = time_label
-
- return x_axis_labels
-
- def _draw_bandwidth_stats(self, attr, width):
- """
- Replaces the x-axis labeling with bandwidth stats. This is done on small
- screens since this information otherwise wouldn't fit.
- """
-
- labeling_line = DEFAULT_CONTENT_HEIGHT + attr.subgraph_height - 4
- self.addstr(labeling_line, 0, ' ' * width) # clear line
-
- runtime = time.time() - attr.stat.start_time
- primary_footer = 'total: %s, avg: %s/sec' % (_size_label(attr.stat.primary.total), _size_label(attr.stat.primary.total / runtime))
- secondary_footer = 'total: %s, avg: %s/sec' % (_size_label(attr.stat.secondary.total), _size_label(attr.stat.secondary.total / runtime))
-
- self.addstr(labeling_line, 1, primary_footer, PRIMARY_COLOR)
- self.addstr(labeling_line, attr.subgraph_width + 1, secondary_footer, SECONDARY_COLOR)
-
- def _draw_accounting_stats(self, attr):
- y = DEFAULT_CONTENT_HEIGHT + attr.subgraph_height - 2
-
- if tor_controller().is_alive():
- hibernate_color = CONFIG['attr.hibernate_color'].get(attr.accounting.status, 'red')
-
- x = self.addstr(y, 0, 'Accounting (', curses.A_BOLD)
- x = self.addstr(y, x, attr.accounting.status, curses.A_BOLD, hibernate_color)
- x = self.addstr(y, x, ')', curses.A_BOLD)
-
- self.addstr(y, 35, 'Time to reset: %s' % str_tools.short_time_label(attr.accounting.time_until_reset))
-
- self.addstr(y + 1, 2, '%s / %s' % (attr.accounting.read_bytes, attr.accounting.read_limit), PRIMARY_COLOR)
- self.addstr(y + 1, 37, '%s / %s' % (attr.accounting.written_bytes, attr.accounting.write_limit), SECONDARY_COLOR)
- else:
- self.addstr(y, 0, 'Accounting:', curses.A_BOLD)
- self.addstr(y, 12, 'Connection Closed...')
-
- def copy_attr(self, attr):
- if attr == '_stats':
- return dict([(key, type(self._stats[key])(self._stats[key])) for key in self._stats])
- else:
- return panel.Panel.copy_attr(self, attr)
-
- def _update_accounting(self, event):
- if not CONFIG['features.graph.bw.accounting.show']:
- self._accounting_stats = None
- elif not self._accounting_stats or time.time() - self._accounting_stats.retrieved >= ACCOUNTING_RATE:
- old_accounting_stats = self._accounting_stats
- self._accounting_stats = tor_controller().get_accounting_stats(None)
-
- # if we either added or removed accounting info then redraw the whole
- # screen to account for resizing
-
- if bool(old_accounting_stats) != bool(self._accounting_stats):
- nyx.controller.get_controller().redraw()
-
- def _update_stats(self, event):
- for stat in self._stats.values():
- stat.bandwidth_event(event)
-
- if self.displayed_stat:
- param = self.get_attr('_stats')[self.displayed_stat]
- update_rate = INTERVAL_SECONDS[self.update_interval]
-
- if param.primary.tick % update_rate == 0:
- self.redraw(True)
-
-
-def _size_label(byte_count, decimal = 1):
- """
- Alias for str_tools.size_label() that accounts for if the user prefers bits
- or bytes.
- """
-
- return str_tools.size_label(byte_count, decimal, is_bytes = CONFIG['features.graph.bw.transferInBytes'])
diff --git a/nyx/header_panel.py b/nyx/header_panel.py
deleted file mode 100644
index 0d6591a..0000000
--- a/nyx/header_panel.py
+++ /dev/null
@@ -1,496 +0,0 @@
-"""
-Top panel for every page, containing basic system and tor related information.
-This expands the information it presents to two columns if there's room
-available.
-"""
-
-import collections
-import os
-import time
-import curses
-import threading
-
-import stem
-
-import nyx.controller
-import nyx.popups
-
-from stem.control import Listener, State
-from stem.util import conf, log, proc, str_tools, system
-from nyx.util import msg, tor_controller, panel, tracker
-
-MIN_DUAL_COL_WIDTH = 141 # minimum width where we'll show two columns
-SHOW_FD_THRESHOLD = 60 # show file descriptor usage if usage is over this percentage
-UPDATE_RATE = 5 # rate in seconds at which we refresh
-
-CONFIG = conf.config_dict('nyx', {
- 'attr.flag_colors': {},
- 'attr.version_status_colors': {},
-})
-
-
-class HeaderPanel(panel.Panel, threading.Thread):
- """
- Top area containing tor settings and system information.
- """
-
- def __init__(self, stdscr):
- panel.Panel.__init__(self, stdscr, 'header', 0)
- threading.Thread.__init__(self)
- self.setDaemon(True)
-
- self._vals = get_sampling()
-
- self._pause_condition = threading.Condition()
- self._halt = False # terminates thread if true
- self._reported_inactive = False
-
- tor_controller().add_status_listener(self.reset_listener)
-
- def is_wide(self, width = None):
- """
- True if we should show two columns of information, False otherwise.
- """
-
- if width is None:
- width = self.get_parent().getmaxyx()[1]
-
- return width >= MIN_DUAL_COL_WIDTH
-
- def get_height(self):
- """
- Provides the height of the content, which is dynamically determined by the
- panel's maximum width.
- """
-
- if self._vals.is_relay:
- return 4 if self.is_wide() else 6
- else:
- return 3 if self.is_wide() else 4
-
- def send_newnym(self):
- """
- Requests a new identity and provides a visual queue.
- """
-
- controller = tor_controller()
-
- if not controller.is_newnym_available():
- return
-
- controller.signal(stem.Signal.NEWNYM)
-
- # If we're wide then the newnym label in this panel will give an
- # indication that the signal was sent. Otherwise use a msg.
-
- if not self.is_wide():
- nyx.popups.show_msg('Requesting a new identity', 1)
-
- def handle_key(self, key):
- if key.match('n'):
- self.send_newnym()
- elif key.match('r') and not self._vals.is_connected:
- # TODO: This is borked. Not quite sure why but our attempt to call
- # PROTOCOLINFO fails with a socket error, followed by completely freezing
- # nyx. This is exposing two bugs...
- #
- # * This should be working. That's a stem issue.
- # * Our interface shouldn't be locking up. That's an nyx issue.
-
- return True
-
- controller = tor_controller()
-
- try:
- controller.connect()
-
- try:
- controller.authenticate() # TODO: should account for our chroot
- except stem.connection.MissingPassword:
- password = nyx.popups.input_prompt('Controller Password: ')
-
- if password:
- controller.authenticate(password)
-
- log.notice("Reconnected to Tor's control port")
- nyx.popups.show_msg('Tor reconnected', 1)
- except Exception as exc:
- nyx.popups.show_msg('Unable to reconnect (%s)' % exc, 3)
- controller.close()
- else:
- return False
-
- return True
-
- def draw(self, width, height):
- vals = self._vals # local reference to avoid concurrency concerns
- is_wide = self.is_wide(width)
-
- # space available for content
-
- left_width = max(width / 2, 77) if is_wide else width
- right_width = width - left_width
-
- self._draw_platform_section(0, 0, left_width, vals)
-
- if vals.is_connected:
- self._draw_ports_section(0, 1, left_width, vals)
- else:
- self._draw_disconnected(0, 1, left_width, vals)
-
- if is_wide:
- self._draw_resource_usage(left_width, 0, right_width, vals)
-
- if vals.is_relay:
- self._draw_fingerprint_and_fd_usage(left_width, 1, right_width, vals)
- self._draw_flags(0, 2, left_width, vals)
- self._draw_exit_policy(left_width, 2, right_width, vals)
- elif vals.is_connected:
- self._draw_newnym_option(left_width, 1, right_width, vals)
- else:
- self._draw_resource_usage(0, 2, left_width, vals)
-
- if vals.is_relay:
- self._draw_fingerprint_and_fd_usage(0, 3, left_width, vals)
- self._draw_flags(0, 4, left_width, vals)
-
- def _draw_platform_section(self, x, y, width, vals):
- """
- Section providing the user's hostname, platform, and version information...
-
- nyx - odin (Linux 3.5.0-52-generic) Tor 0.2.5.1-alpha-dev (unrecommended)
- |------ platform (40 characters) ------| |----------- tor version -----------|
- """
-
- initial_x, space_left = x, min(width, 40)
-
- x = self.addstr(y, x, vals.format('nyx - {hostname}', space_left))
- space_left -= x - initial_x
-
- if space_left >= 10:
- self.addstr(y, x, ' (%s)' % vals.format('{platform}', space_left - 3))
-
- x, space_left = initial_x + 43, width - 43
-
- if vals.version != 'Unknown' and space_left >= 10:
- x = self.addstr(y, x, vals.format('Tor {version}', space_left))
- space_left -= x - 43 - initial_x
-
- if space_left >= 7 + len(vals.version_status):
- version_color = CONFIG['attr.version_status_colors'].get(vals.version_status, 'white')
-
- x = self.addstr(y, x, ' (')
- x = self.addstr(y, x, vals.version_status, version_color)
- self.addstr(y, x, ')')
-
- def _draw_ports_section(self, x, y, width, vals):
- """
- Section providing our nickname, address, and port information...
-
- Unnamed - 0.0.0.0:7000, Control Port (cookie): 9051
- """
-
- if not vals.is_relay:
- x = self.addstr(y, x, 'Relaying Disabled', 'cyan')
- else:
- x = self.addstr(y, x, vals.format('{nickname} - {address}:{or_port}'))
-
- if vals.dir_port != '0':
- x = self.addstr(y, x, vals.format(', Dir Port: {dir_port}'))
-
- if vals.control_port:
- if width >= x + 19 + len(vals.control_port) + len(vals.auth_type):
- auth_color = 'red' if vals.auth_type == 'open' else 'green'
-
- x = self.addstr(y, x, ', Control Port (')
- x = self.addstr(y, x, vals.auth_type, auth_color)
- self.addstr(y, x, vals.format('): {control_port}'))
- else:
- self.addstr(y, x, vals.format(', Control Port: {control_port}'))
- elif vals.socket_path:
- self.addstr(y, x, vals.format(', Control Socket: {socket_path}'))
-
- def _draw_disconnected(self, x, y, width, vals):
- """
- Message indicating that tor is disconnected...
-
- Tor Disconnected (15:21 07/13/2014, press r to reconnect)
- """
-
- x = self.addstr(y, x, 'Tor Disconnected', curses.A_BOLD, 'red')
- last_heartbeat = time.strftime('%H:%M %m/%d/%Y', time.localtime(vals.last_heartbeat))
- self.addstr(y, x, ' (%s, press r to reconnect)' % last_heartbeat)
-
- def _draw_resource_usage(self, x, y, width, vals):
- """
- System resource usage of the tor process...
-
- cpu: 0.0% tor, 1.0% nyx mem: 0 (0.0%) pid: 16329 uptime: 12-20:42:07
- """
-
- if vals.start_time:
- if not vals.is_connected:
- now = vals.connection_time
- elif self.is_paused():
- now = self.get_pause_time()
- else:
- now = time.time()
-
- uptime = str_tools.short_time_label(now - vals.start_time)
- else:
- uptime = ''
-
- sys_fields = (
- (0, vals.format('cpu: {tor_cpu}% tor, {nyx_cpu}% nyx')),
- (27, vals.format('mem: {memory} ({memory_percent}%)')),
- (47, vals.format('pid: {pid}')),
- (59, 'uptime: %s' % uptime),
- )
-
- for (start, label) in sys_fields:
- if width >= start + len(label):
- self.addstr(y, x + start, label)
- else:
- break
-
- def _draw_fingerprint_and_fd_usage(self, x, y, width, vals):
- """
- Presents our fingerprint, and our file descriptor usage if we're running
- out...
-
- fingerprint: 1A94D1A794FCB2F8B6CBC179EF8FDD4008A98D3B, file desc: 900 / 1000 (90%)
- """
-
- initial_x, space_left = x, width
-
- x = self.addstr(y, x, vals.format('fingerprint: {fingerprint}', width))
- space_left -= x - initial_x
-
- if space_left >= 30 and vals.fd_used and vals.fd_limit != -1:
- fd_percent = 100 * vals.fd_used / vals.fd_limit
-
- if fd_percent >= SHOW_FD_THRESHOLD:
- if fd_percent >= 95:
- percentage_format = (curses.A_BOLD, 'red')
- elif fd_percent >= 90:
- percentage_format = ('red',)
- elif fd_percent >= 60:
- percentage_format = ('yellow',)
- else:
- percentage_format = ()
-
- x = self.addstr(y, x, ', file descriptors' if space_left >= 37 else ', file desc')
- x = self.addstr(y, x, vals.format(': {fd_used} / {fd_limit} ('))
- x = self.addstr(y, x, '%i%%' % fd_percent, *percentage_format)
- self.addstr(y, x, ')')
-
- def _draw_flags(self, x, y, width, vals):
- """
- Presents flags held by our relay...
-
- flags: Running, Valid
- """
-
- x = self.addstr(y, x, 'flags: ')
-
- if vals.flags:
- for i, flag in enumerate(vals.flags):
- flag_color = CONFIG['attr.flag_colors'].get(flag, 'white')
- x = self.addstr(y, x, flag, curses.A_BOLD, flag_color)
-
- if i < len(vals.flags) - 1:
- x = self.addstr(y, x, ', ')
- else:
- self.addstr(y, x, 'none', curses.A_BOLD, 'cyan')
-
- def _draw_exit_policy(self, x, y, width, vals):
- """
- Presents our exit policy...
-
- exit policy: reject *:*
- """
-
- x = self.addstr(y, x, 'exit policy: ')
-
- if not vals.exit_policy:
- return
-
- rules = list(vals.exit_policy.strip_private().strip_default())
-
- for i, rule in enumerate(rules):
- policy_color = 'green' if rule.is_accept else 'red'
- x = self.addstr(y, x, str(rule), curses.A_BOLD, policy_color)
-
- if i < len(rules) - 1:
- x = self.addstr(y, x, ', ')
-
- if vals.exit_policy.has_default():
- if rules:
- x = self.addstr(y, x, ', ')
-
- self.addstr(y, x, '<default>', curses.A_BOLD, 'cyan')
-
- def _draw_newnym_option(self, x, y, width, vals):
- """
- Provide a notice for requiesting a new identity, and time until it's next
- available if in the process of building circuits.
- """
-
- if vals.newnym_wait == 0:
- self.addstr(y, x, "press 'n' for a new identity")
- else:
- plural = 's' if vals.newnym_wait > 1 else ''
- self.addstr(y, x, 'building circuits, available again in %i second%s' % (vals.newnym_wait, plural))
-
- def run(self):
- """
- Keeps stats updated, checking for new information at a set rate.
- """
-
- last_ran = -1
-
- while not self._halt:
- if self.is_paused() or not self._vals.is_connected or (time.time() - last_ran) < UPDATE_RATE:
- with self._pause_condition:
- if not self._halt:
- self._pause_condition.wait(0.2)
-
- continue # done waiting, try again
-
- self._update()
- last_ran = time.time()
-
- def stop(self):
- """
- Halts further resolutions and terminates the thread.
- """
-
- with self._pause_condition:
- self._halt = True
- self._pause_condition.notifyAll()
-
- def reset_listener(self, controller, event_type, _):
- self._update()
-
- if event_type == State.CLOSED:
- log.notice('Tor control port closed')
-
- def _update(self):
- previous_height = self.get_height()
- self._vals = get_sampling(self._vals)
-
- if self._vals.fd_used and self._vals.fd_limit != -1:
- fd_percent = 100 * self._vals.fd_used / self._vals.fd_limit
-
- if fd_percent >= 90:
- log_msg = msg('panel.header.fd_used_at_ninety_percent', percentage = fd_percent)
- log.log_once('fd_used_at_ninety_percent', log.WARN, log_msg)
- log.DEDUPLICATION_MESSAGE_IDS.add('fd_used_at_sixty_percent')
- elif fd_percent >= 60:
- log_msg = msg('panel.header.fd_used_at_sixty_percent', percentage = fd_percent)
- log.log_once('fd_used_at_sixty_percent', log.NOTICE, log_msg)
-
- if self._vals.is_connected:
- if not self._reported_inactive and (time.time() - self._vals.last_heartbeat) >= 10:
- self._reported_inactive = True
- log.notice('Relay unresponsive (last heartbeat: %s)' % time.ctime(self._vals.last_heartbeat))
- elif self._reported_inactive and (time.time() - self._vals.last_heartbeat) < 10:
- self._reported_inactive = False
- log.notice('Relay resumed')
-
- if previous_height != self.get_height():
- # We're toggling between being a relay and client, causing the height
- # of this panel to change. Redraw all content so we don't get
- # overlapping content.
-
- nyx.controller.get_controller().redraw()
- else:
- self.redraw(True) # just need to redraw ourselves
-
-
-def get_sampling(last_sampling = None):
- controller = tor_controller()
- retrieved = time.time()
-
- pid = controller.get_pid('')
- tor_resources = tracker.get_resource_tracker().get_value()
- nyx_total_cpu_time = sum(os.times()[:3])
-
- or_listeners = controller.get_listeners(Listener.OR, [])
- control_listeners = controller.get_listeners(Listener.CONTROL, [])
-
- if controller.get_conf('HashedControlPassword', None):
- auth_type = 'password'
- elif controller.get_conf('CookieAuthentication', None) == '1':
- auth_type = 'cookie'
- else:
- auth_type = 'open'
-
- try:
- fd_used = proc.file_descriptors_used(pid)
- except IOError:
- fd_used = None
-
- if last_sampling:
- nyx_cpu_delta = nyx_total_cpu_time - last_sampling.nyx_total_cpu_time
- nyx_time_delta = retrieved - last_sampling.retrieved
-
- python_cpu_time = nyx_cpu_delta / nyx_time_delta
- sys_call_cpu_time = 0.0 # TODO: add a wrapper around call() to get this
-
- nyx_cpu = python_cpu_time + sys_call_cpu_time
- else:
- nyx_cpu = 0.0
-
- attr = {
- 'retrieved': retrieved,
- 'is_connected': controller.is_alive(),
- 'connection_time': controller.connection_time(),
- 'last_heartbeat': controller.get_latest_heartbeat(),
-
- 'fingerprint': controller.get_info('fingerprint', 'Unknown'),
- 'nickname': controller.get_conf('Nickname', ''),
- 'newnym_wait': controller.get_newnym_wait(),
- 'exit_policy': controller.get_exit_policy(None),
- 'flags': getattr(controller.get_network_status(default = None), 'flags', []),
-
- 'version': str(controller.get_version('Unknown')).split()[0],
- 'version_status': controller.get_info('status/version/current', 'Unknown'),
-
- 'address': or_listeners[0][0] if (or_listeners and or_listeners[0][0] != '0.0.0.0') else controller.get_info('address', 'Unknown'),
- 'or_port': or_listeners[0][1] if or_listeners else '',
- 'dir_port': controller.get_conf('DirPort', '0'),
- 'control_port': str(control_listeners[0][1]) if control_listeners else None,
- 'socket_path': controller.get_conf('ControlSocket', None),
- 'is_relay': bool(or_listeners),
-
- 'auth_type': auth_type,
- 'pid': pid,
- 'start_time': system.start_time(pid),
- 'fd_limit': int(controller.get_info('process/descriptor-limit', '-1')),
- 'fd_used': fd_used,
-
- 'nyx_total_cpu_time': nyx_total_cpu_time,
- 'tor_cpu': '%0.1f' % (100 * tor_resources.cpu_sample),
- 'nyx_cpu': nyx_cpu,
- 'memory': str_tools.size_label(tor_resources.memory_bytes) if tor_resources.memory_bytes > 0 else 0,
- 'memory_percent': '%0.1f' % (100 * tor_resources.memory_percent),
-
- 'hostname': os.uname()[1],
- 'platform': '%s %s' % (os.uname()[0], os.uname()[2]), # [platform name] [version]
- }
-
- class Sampling(collections.namedtuple('Sampling', attr.keys())):
- def __init__(self, **attr):
- super(Sampling, self).__init__(**attr)
- self._attr = attr
-
- def format(self, message, crop_width = None):
- formatted_msg = message.format(**self._attr)
-
- if crop_width:
- formatted_msg = str_tools.crop(formatted_msg, crop_width)
-
- return formatted_msg
-
- return Sampling(**attr)
diff --git a/nyx/log_panel.py b/nyx/log_panel.py
deleted file mode 100644
index 708a679..0000000
--- a/nyx/log_panel.py
+++ /dev/null
@@ -1,454 +0,0 @@
-"""
-Panel providing a chronological log of events its been configured to listen
-for. This provides prepopulation from the log file and supports filtering by
-regular expressions.
-"""
-
-import os
-import time
-import curses
-import threading
-
-import stem.response.events
-
-import nyx.arguments
-import nyx.popups
-import nyx.util.log
-
-from nyx.util import join, panel, tor_controller, ui_tools
-from stem.util import conf, log
-
-
-def conf_handler(key, value):
- if key == 'features.log.prepopulateReadLimit':
- return max(0, value)
- elif key == 'features.log.maxRefreshRate':
- return max(10, value)
- elif key == 'cache.log_panel.size':
- return max(1000, value)
-
-
-CONFIG = conf.config_dict('nyx', {
- 'attr.log_color': {},
- 'cache.log_panel.size': 1000,
- 'features.logFile': '',
- 'features.log.showDuplicateEntries': False,
- 'features.log.prepopulate': True,
- 'features.log.prepopulateReadLimit': 5000,
- 'features.log.maxRefreshRate': 300,
- 'features.log.regex': [],
- 'msg.misc.event_types': '',
- 'startup.events': 'N3',
-}, conf_handler)
-
-# The height of the drawn content is estimated based on the last time we redrew
-# the panel. It's chiefly used for scrolling and the bar indicating its
-# position. Letting the estimate be too inaccurate results in a display bug, so
-# redraws the display if it's off by this threshold.
-
-CONTENT_HEIGHT_REDRAW_THRESHOLD = 3
-
-# Log buffer so we start collecting stem/nyx events when imported. This is used
-# to make our LogPanel when curses initializes.
-
-stem_logger = log.get_logger()
-NYX_LOGGER = log.LogBuffer(log.Runlevel.DEBUG, yield_records = True)
-stem_logger.addHandler(NYX_LOGGER)
-
-
-class LogPanel(panel.Panel, threading.Thread):
- """
- Listens for and displays tor, nyx, and stem events. This prepopulates
- from tor's log file if it exists.
- """
-
- def __init__(self, stdscr):
- panel.Panel.__init__(self, stdscr, 'log', 0)
- threading.Thread.__init__(self)
- self.setDaemon(True)
-
- logged_events = nyx.arguments.expand_events(CONFIG['startup.events'])
- self._event_log = nyx.util.log.LogGroup(CONFIG['cache.log_panel.size'], group_by_day = True)
- self._event_types = nyx.util.log.listen_for_events(self._register_tor_event, logged_events)
- self._log_file = nyx.util.log.LogFileOutput(CONFIG['features.logFile'])
- self._filter = nyx.util.log.LogFilters(initial_filters = CONFIG['features.log.regex'])
- self._show_duplicates = CONFIG['features.log.showDuplicateEntries']
-
- self.set_pause_attr('_event_log')
-
- self._halt = False # terminates thread if true
- self._pause_condition = threading.Condition()
- self._has_new_event = False
-
- # fetches past tor events from log file, if available
-
- if CONFIG['features.log.prepopulate']:
- log_location = nyx.util.log.log_file_path(tor_controller())
-
- if log_location:
- try:
- for entry in reversed(list(nyx.util.log.read_tor_log(log_location, CONFIG['features.log.prepopulateReadLimit']))):
- if entry.type in self._event_types:
- self._event_log.add(entry)
- except IOError as exc:
- log.info('Unable to read log located at %s: %s' % (log_location, exc))
- except ValueError as exc:
- log.info(str(exc))
-
- self._last_content_height = len(self._event_log) # height of the rendered content when last drawn
- self._scroll = 0
-
- # merge NYX_LOGGER into us, and listen for its future events
-
- for event in NYX_LOGGER:
- self._register_nyx_event(event)
-
- NYX_LOGGER.emit = self._register_nyx_event
-
- def set_duplicate_visability(self, is_visible):
- """
- Sets if duplicate log entries are collaped or expanded.
-
- :param bool is_visible: if **True** all log entries are shown, otherwise
- they're deduplicated
- """
-
- self._show_duplicates = is_visible
-
- def get_filter(self):
- """
- Provides our currently selected regex filter.
- """
-
- return self._filter
-
- def show_filter_prompt(self):
- """
- Prompts the user to add a new regex filter.
- """
-
- regex_input = nyx.popups.input_prompt('Regular expression: ')
-
- if regex_input:
- self._filter.select(regex_input)
-
- def show_event_selection_prompt(self):
- """
- Prompts the user to select the events being listened for.
- """
-
- # allow user to enter new types of events to log - unchanged if left blank
-
- with nyx.popups.popup_window(16, 80) as (popup, width, height):
- if popup:
- # displays the available flags
-
- popup.win.box()
- popup.addstr(0, 0, 'Event Types:', curses.A_STANDOUT)
- event_lines = CONFIG['msg.misc.event_types'].split('\n')
-
- for i in range(len(event_lines)):
- popup.addstr(i + 1, 1, event_lines[i][6:])
-
- popup.win.refresh()
-
- user_input = nyx.popups.input_prompt('Events to log: ')
-
- if user_input:
- try:
- user_input = user_input.replace(' ', '') # strip spaces
- event_types = nyx.arguments.expand_events(user_input)
-
- if event_types != self._event_types:
- self._event_types = nyx.util.log.listen_for_events(self._register_tor_event, event_types)
- self.redraw(True)
- except ValueError as exc:
- nyx.popups.show_msg('Invalid flags: %s' % str(exc), 2)
-
- def show_snapshot_prompt(self):
- """
- Lets user enter a path to take a snapshot, canceling if left blank.
- """
-
- path_input = nyx.popups.input_prompt('Path to save log snapshot: ')
-
- if path_input:
- try:
- self.save_snapshot(path_input)
- nyx.popups.show_msg('Saved: %s' % path_input, 2)
- except IOError as exc:
- nyx.popups.show_msg('Unable to save snapshot: %s' % exc, 2)
-
- def clear(self):
- """
- Clears the contents of the event log.
- """
-
- self._event_log = nyx.util.log.LogGroup(CONFIG['cache.log_panel.size'], group_by_day = True)
- self.redraw(True)
-
- def save_snapshot(self, path):
- """
- Saves the log events currently being displayed to the given path. This
- takes filers into account. This overwrites the file if it already exists.
-
- :param str path: path where to save the log snapshot
-
- :raises: **IOError** if unsuccessful
- """
-
- path = os.path.abspath(os.path.expanduser(path))
-
- # make dir if the path doesn't already exist
-
- base_dir = os.path.dirname(path)
-
- try:
- if not os.path.exists(base_dir):
- os.makedirs(base_dir)
- except OSError as exc:
- raise IOError("unable to make directory '%s'" % base_dir)
-
- event_log = list(self._event_log)
- event_filter = self._filter.clone()
-
- with open(path, 'w') as snapshot_file:
- try:
- for entry in reversed(event_log):
- if event_filter.match(entry.display_message):
- snapshot_file.write(entry.display_message + '\n')
- except Exception as exc:
- raise IOError("unable to write to '%s': %s" % (path, exc))
-
- def handle_key(self, key):
- if key.is_scroll():
- page_height = self.get_preferred_size()[0] - 1
- new_scroll = ui_tools.get_scroll_position(key, self._scroll, page_height, self._last_content_height)
-
- if self._scroll != new_scroll:
- self._scroll = new_scroll
- self.redraw(True)
- elif key.match('u'):
- self.set_duplicate_visability(not self._show_duplicates)
- self.redraw(True)
- elif key.match('c'):
- msg = 'This will clear the log. Are you sure (c again to confirm)?'
- key_press = nyx.popups.show_msg(msg, attr = curses.A_BOLD)
-
- if key_press.match('c'):
- self.clear()
- elif key.match('f'):
- with panel.CURSES_LOCK:
- initial_selection = 1 if self._filter.selection() else 0
- options = ['None'] + self._filter.latest_selections() + ['New...']
- selection = nyx.popups.show_menu('Log Filter:', options, initial_selection)
-
- if selection == 0:
- self._filter.select(None)
- elif selection == len(options) - 1:
- # selected 'New...' option - prompt user to input regular expression
- self.show_filter_prompt()
- elif selection != -1:
- self._filter.select(self._filter.latest_selections()[selection - 1])
- elif key.match('e'):
- self.show_event_selection_prompt()
- elif key.match('a'):
- self.show_snapshot_prompt()
- else:
- return False
-
- return True
-
- def get_help(self):
- return [
- ('up arrow', 'scroll log up a line', None),
- ('down arrow', 'scroll log down a line', None),
- ('a', 'save snapshot of the log', None),
- ('e', 'change logged events', None),
- ('f', 'log regex filter', 'enabled' if self._filter.selection() else 'disabled'),
- ('u', 'duplicate log entries', 'visible' if self._show_duplicates else 'hidden'),
- ('c', 'clear event log', None),
- ]
-
- def draw(self, width, height):
- self._scroll = max(0, min(self._scroll, self._last_content_height - height + 1))
-
- event_log = list(self.get_attr('_event_log'))
- event_filter = self._filter.clone()
- event_types = list(self._event_types)
- scroll = int(self._scroll)
- last_content_height = self._last_content_height
- show_duplicates = self._show_duplicates
-
- is_scrollbar_visible = last_content_height > height - 1
-
- if is_scrollbar_visible:
- self.add_scroll_bar(scroll, scroll + height - 1, last_content_height, 1)
-
- x, y = 3 if is_scrollbar_visible else 1, 1 - scroll
-
- # group entries by date, filtering out those that aren't visible
-
- day_to_entries, today = {}, nyx.util.log.day_count(time.time())
-
- for entry in event_log:
- if entry.is_duplicate and not show_duplicates:
- continue # deduplicated message
- elif not event_filter.match(entry.display_message):
- continue # filter doesn't match log message
-
- day_to_entries.setdefault(entry.day_count(), []).append(entry)
-
- for day in sorted(day_to_entries.keys(), reverse = True):
- if day == today:
- for entry in day_to_entries[day]:
- y = self._draw_entry(x, y, width, entry, show_duplicates)
- else:
- original_y, y = y, y + 1
-
- for entry in day_to_entries[day]:
- y = self._draw_entry(x, y, width, entry, show_duplicates)
-
- ui_tools.draw_box(self, original_y, x - 1, width - x + 1, y - original_y + 1, curses.A_BOLD, 'yellow')
- time_label = time.strftime(' %B %d, %Y ', time.localtime(day_to_entries[day][0].timestamp))
- self.addstr(original_y, x + 1, time_label, curses.A_BOLD, curses.A_BOLD, 'yellow')
-
- y += 1
-
- # drawing the title after the content, so we'll clear content from the top line
-
- if self.is_title_visible():
- self._draw_title(width, event_types, event_filter)
-
- # redraw the display if...
- # - last_content_height was off by too much
- # - we're off the bottom of the page
-
- new_content_height = y + scroll - 1
- content_height_delta = abs(last_content_height - new_content_height)
- force_redraw, force_redraw_reason = True, ''
-
- if content_height_delta >= CONTENT_HEIGHT_REDRAW_THRESHOLD:
- force_redraw_reason = 'estimate was off by %i' % content_height_delta
- elif new_content_height > height and self._scroll + height - 1 > new_content_height:
- force_redraw_reason = 'scrolled off the bottom of the page'
- elif not is_scrollbar_visible and new_content_height > height - 1:
- force_redraw_reason = "scroll bar wasn't previously visible"
- elif is_scrollbar_visible and new_content_height <= height - 1:
- force_redraw_reason = "scroll bar shouldn't be visible"
- else:
- force_redraw = False
-
- self._last_content_height = new_content_height
- self._has_new_event = False
-
- if force_redraw:
- log.debug('redrawing the log panel with the corrected content height (%s)' % force_redraw_reason)
- self.redraw(True)
-
- def _draw_title(self, width, event_types, event_filter):
- """
- Panel title with the event types we're logging and our regex filter if set.
- """
-
- self.addstr(0, 0, ' ' * width) # clear line
- title_comp = list(nyx.util.log.condense_runlevels(*event_types))
-
- if event_filter.selection():
- title_comp.append('filter: %s' % event_filter.selection())
-
- title_comp_str = join(title_comp, ', ', width - 10)
- title = 'Events (%s):' % title_comp_str if title_comp_str else 'Events:'
-
- self.addstr(0, 0, title, curses.A_STANDOUT)
-
- def _draw_entry(self, x, y, width, entry, show_duplicates):
- """
- Presents a log entry with line wrapping.
- """
-
- min_x, msg = x + 2, entry.display_message
- boldness = curses.A_BOLD if 'ERR' in entry.type else curses.A_NORMAL # emphasize ERR messages
- color = CONFIG['attr.log_color'].get(entry.type, 'white')
-
- for line in msg.splitlines():
- x, y = self.addstr_wrap(y, x, line, width, min_x, boldness, color)
-
- if entry.duplicates and not show_duplicates:
- duplicate_count = len(entry.duplicates) - 1
- plural = 's' if duplicate_count > 1 else ''
- duplicate_msg = ' [%i duplicate%s hidden]' % (duplicate_count, plural)
- x, y = self.addstr_wrap(y, x, duplicate_msg, width, min_x, curses.A_BOLD, 'green')
-
- return y + 1
-
- def run(self):
- """
- Redraws the display, coalescing updates if events are rapidly logged (for
- instance running at the DEBUG runlevel) while also being immediately
- responsive if additions are less frequent.
- """
-
- last_ran, last_day = -1, nyx.util.log.day_count(time.time())
-
- while not self._halt:
- current_day = nyx.util.log.day_count(time.time())
- time_since_reset = time.time() - last_ran
- max_log_update_rate = CONFIG['features.log.maxRefreshRate'] / 1000.0
-
- sleep_time = 0
-
- if (not self._has_new_event and last_day == current_day) or self.is_paused():
- sleep_time = 5
- elif time_since_reset < max_log_update_rate:
- sleep_time = max(0.05, max_log_update_rate - time_since_reset)
-
- if sleep_time:
- with self._pause_condition:
- if not self._halt:
- self._pause_condition.wait(sleep_time)
-
- continue
-
- last_ran, last_day = time.time(), current_day
- self.redraw(True)
-
- def stop(self):
- """
- Halts further updates and terminates the thread.
- """
-
- with self._pause_condition:
- self._halt = True
- self._pause_condition.notifyAll()
-
- def _register_tor_event(self, event):
- msg = ' '.join(str(event).split(' ')[1:])
-
- if isinstance(event, stem.response.events.BandwidthEvent):
- msg = 'READ: %i, WRITTEN: %i' % (event.read, event.written)
- elif isinstance(event, stem.response.events.LogEvent):
- msg = event.message
-
- self._register_event(nyx.util.log.LogEntry(event.arrived_at, event.type, msg))
-
- def _register_nyx_event(self, record):
- if record.levelname == 'WARNING':
- record.levelname = 'WARN'
-
- self._register_event(nyx.util.log.LogEntry(int(record.created), 'NYX_%s' % record.levelname, record.msg))
-
- def _register_event(self, event):
- if event.type not in self._event_types:
- return
-
- self._event_log.add(event)
- self._log_file.write(event.display_message)
-
- # notifies the display that it has new content
-
- if self._filter.match(event.display_message):
- self._has_new_event = True
-
- with self._pause_condition:
- self._pause_condition.notifyAll()
diff --git a/nyx/menu/actions.py b/nyx/menu/actions.py
index 0105615..222e3e7 100644
--- a/nyx/menu/actions.py
+++ b/nyx/menu/actions.py
@@ -4,10 +4,10 @@ Generates the menu for nyx, binding options with their related actions.
import functools
-import nyx.popups
import nyx.controller
+import nyx.panel.graph
+import nyx.popups
import nyx.menu.item
-import nyx.graph_panel
import nyx.util.tracker
from nyx.util import tor_controller, ui_tools
@@ -167,7 +167,7 @@ def make_graph_menu(graph_panel):
interval_menu = nyx.menu.item.Submenu('Interval')
interval_group = nyx.menu.item.SelectionGroup(functools.partial(setattr, graph_panel, 'update_interval'), graph_panel.update_interval)
- for interval in nyx.graph_panel.Interval:
+ for interval in nyx.panel.graph.Interval:
interval_menu.add(nyx.menu.item.SelectionMenuItem(interval, interval_group, interval))
graph_menu.add(interval_menu)
@@ -177,7 +177,7 @@ def make_graph_menu(graph_panel):
bounds_menu = nyx.menu.item.Submenu('Bounds')
bounds_group = nyx.menu.item.SelectionGroup(functools.partial(setattr, graph_panel, 'bounds_type'), graph_panel.bounds_type)
- for bounds_type in nyx.graph_panel.Bounds:
+ for bounds_type in nyx.panel.graph.Bounds:
bounds_menu.add(nyx.menu.item.SelectionMenuItem(bounds_type, bounds_group, bounds_type))
graph_menu.add(bounds_menu)
diff --git a/nyx/panel/__init__.py b/nyx/panel/__init__.py
new file mode 100644
index 0000000..0f25fac
--- /dev/null
+++ b/nyx/panel/__init__.py
@@ -0,0 +1,11 @@
+"""
+Panels consisting the nyx interface.
+"""
+
+__all__ = [
+ 'config',
+ 'connection',
+ 'header',
+ 'log',
+ 'torrc',
+]
diff --git a/nyx/panel/config.py b/nyx/panel/config.py
new file mode 100644
index 0000000..2352fe7
--- /dev/null
+++ b/nyx/panel/config.py
@@ -0,0 +1,357 @@
+"""
+Panel presenting the configuration state for tor or nyx. Options can be edited
+and the resulting configuration files saved.
+"""
+
+import curses
+import os
+
+import nyx.controller
+import nyx.popups
+
+import stem.control
+import stem.manual
+
+from nyx.util import DATA_DIR, panel, tor_controller, ui_tools
+
+from stem.util import conf, enum, log, str_tools
+
+SortAttr = enum.Enum('NAME', 'VALUE', 'VALUE_TYPE', 'CATEGORY', 'USAGE', 'SUMMARY', 'DESCRIPTION', 'MAN_PAGE_ENTRY', 'IS_SET')
+
+DETAILS_HEIGHT = 8
+NAME_WIDTH = 25
+VALUE_WIDTH = 15
+
+
+def conf_handler(key, value):
+ if key == 'features.config.order':
+ return conf.parse_enum_csv(key, value[0], SortAttr, 3)
+
+
+CONFIG = conf.config_dict('nyx', {
+ 'attr.config.category_color': {},
+ 'attr.config.sort_color': {},
+ 'features.config.order': [SortAttr.MAN_PAGE_ENTRY, SortAttr.NAME, SortAttr.IS_SET],
+ 'features.config.state.showPrivateOptions': False,
+ 'features.config.state.showVirtualOptions': False,
+}, conf_handler)
+
+
+class ConfigEntry(object):
+ """
+ Configuration option presented in the panel.
+
+ :var str name: name of the configuration option
+ :var str value_type: type of value
+ :var stem.manual.ConfigOption manual: manual information about the option
+ """
+
+ def __init__(self, name, value_type, manual):
+ self.name = name
+ self.value_type = value_type
+ self.manual = manual.config_options.get(name, stem.manual.ConfigOption(name))
+ self._index = manual.config_options.keys().index(name) if name in manual.config_options else 99999
+
+ def value(self):
+ """
+ Provides the value of this configuration option.
+
+ :returns: **str** representation of the current config value
+ """
+
+ values = tor_controller().get_conf(self.name, [], True)
+
+ if not values:
+ return '<none>'
+ elif self.value_type == 'Boolean' and values[0] in ('0', '1'):
+ return 'False' if values[0] == '0' else 'True'
+ elif self.value_type == 'DataSize' and values[0].isdigit():
+ return str_tools.size_label(int(values[0]))
+ elif self.value_type == 'TimeInterval' and values[0].isdigit():
+ return str_tools.time_label(int(values[0]), is_long = True)
+ else:
+ return ', '.join(values)
+
+ def is_set(self):
+ """
+ Checks if the configuration option has a custom value.
+
+ :returns: **True** if the option has a custom value, **False** otherwise
+ """
+
+ return tor_controller().is_set(self.name, False)
+
+ def sort_value(self, attr):
+ """
+ Provides a heuristic for sorting by a given value.
+
+ :param SortAttr attr: sort attribute to provide a heuristic for
+
+ :returns: comparable value for sorting
+ """
+
+ if attr == SortAttr.CATEGORY:
+ return self.manual.category
+ elif attr == SortAttr.NAME:
+ return self.name
+ elif attr == SortAttr.VALUE:
+ return self.value()
+ elif attr == SortAttr.VALUE_TYPE:
+ return self.value_type
+ elif attr == SortAttr.USAGE:
+ return self.manual.usage
+ elif attr == SortAttr.SUMMARY:
+ return self.manual.summary
+ elif attr == SortAttr.DESCRIPTION:
+ return self.manual.description
+ elif attr == SortAttr.MAN_PAGE_ENTRY:
+ return self._index
+ elif attr == SortAttr.IS_SET:
+ return not self.is_set()
+
+
+class ConfigPanel(panel.Panel):
+ """
+ Editor for tor's configuration.
+ """
+
+ def __init__(self, stdscr):
+ panel.Panel.__init__(self, stdscr, 'configuration', 0)
+
+ self._contents = []
+ self._scroller = ui_tools.Scroller(True)
+ self._sort_order = CONFIG['features.config.order']
+ self._show_all = False # show all options, or just the important ones
+
+ cached_manual_path = os.path.join(DATA_DIR, 'manual')
+
+ if os.path.exists(cached_manual_path):
+ manual = stem.manual.Manual.from_cache(cached_manual_path)
+ else:
+ try:
+ manual = stem.manual.Manual.from_man()
+
+ try:
+ manual.save(cached_manual_path)
+ except IOError as exc:
+ log.debug("Unable to cache manual information to '%s'. This is fine, but means starting Nyx takes a little longer than usual: " % (cached_manual_path, exc))
+ except IOError as exc:
+ log.debug("Unable to use 'man tor' to get information about config options (%s), using bundled information instead" % exc)
+ manual = stem.manual.Manual.from_cache()
+
+ try:
+ for line in tor_controller().get_info('config/names').splitlines():
+ # Lines of the form "<option> <type>[ <documentation>]". Documentation
+ # was apparently only in old tor versions like 0.2.1.25.
+
+ if ' ' not in line:
+ continue
+
+ line_comp = line.split()
+ name, value_type = line_comp[0], line_comp[1]
+
+ # skips private and virtual entries if not configured to show them
+
+ if name.startswith('__') and not CONFIG['features.config.state.showPrivateOptions']:
+ continue
+ elif value_type == 'Virtual' and not CONFIG['features.config.state.showVirtualOptions']:
+ continue
+
+ self._contents.append(ConfigEntry(name, value_type, manual))
+
+ self._contents = sorted(self._contents, key = lambda entry: [entry.sort_value(field) for field in self._sort_order])
+ except stem.ControllerError as exc:
+ log.warn('Unable to determine the configuration options tor supports: %s' % exc)
+
+ def show_sort_dialog(self):
+ """
+ Provides the dialog for sorting our configuration options.
+ """
+
+ sort_colors = dict([(attr, CONFIG['attr.config.sort_color'].get(attr, 'white')) for attr in SortAttr])
+ results = nyx.popups.show_sort_dialog('Config Option Ordering:', SortAttr, self._sort_order, sort_colors)
+
+ if results:
+ self._sort_order = results
+ self._contents = sorted(self._contents, key = lambda entry: [entry.sort_value(field) for field in self._sort_order])
+
+ def show_write_dialog(self):
+ """
+ Confirmation dialog for saving tor's configuration.
+ """
+
+ selection, controller = 1, tor_controller()
+ config_text = controller.get_info('config-text', None)
+ config_lines = config_text.splitlines() if config_text else []
+
+ with nyx.popups.popup_window(len(config_lines) + 2) as (popup, width, height):
+ if not popup or height <= 2:
+ return
+
+ while True:
+ height, width = popup.get_preferred_size() # allow us to be resized
+ popup.win.erase()
+
+ for i, full_line in enumerate(config_lines):
+ line = str_tools.crop(full_line, width - 2)
+ option, arg = line.split(' ', 1) if ' ' in line else (line, '')
+
+ popup.addstr(i + 1, 1, option, curses.A_BOLD, 'green')
+ popup.addstr(i + 1, len(option) + 2, arg, curses.A_BOLD, 'cyan')
+
+ x = width - 16
+
+ for i, option in enumerate(['Save', 'Cancel']):
+ x = popup.addstr(height - 2, x, '[')
+ x = popup.addstr(height - 2, x, option, curses.A_BOLD, curses.A_STANDOUT if i == selection else curses.A_NORMAL)
+ x = popup.addstr(height - 2, x, '] ')
+
+ popup.win.box()
+ popup.addstr(0, 0, 'Torrc to save:', curses.A_STANDOUT)
+ popup.win.refresh()
+
+ key = nyx.controller.get_controller().key_input()
+
+ if key.match('left'):
+ selection = max(0, selection - 1)
+ elif key.match('right'):
+ selection = min(1, selection + 1)
+ elif key.is_selection():
+ if selection == 0:
+ try:
+ controller.save_conf()
+ nyx.popups.show_msg('Saved configuration to %s' % controller.get_info('config-file', '<unknown>'), 2)
+ except IOError as exc:
+ nyx.popups.show_msg('Unable to save configuration (%s)' % exc.strerror, 2)
+
+ break
+ elif key.match('esc'):
+ break # esc - cancel
+
+ def handle_key(self, key):
+ if key.is_scroll():
+ page_height = self.get_preferred_size()[0] - DETAILS_HEIGHT
+ is_changed = self._scroller.handle_key(key, self._get_config_options(), page_height)
+
+ if is_changed:
+ self.redraw(True)
+ elif key.is_selection():
+ selection = self._scroller.get_cursor_selection(self._get_config_options())
+ initial_value = selection.value() if selection.is_set() else ''
+ new_value = nyx.popups.input_prompt('%s Value (esc to cancel): ' % selection.name, initial_value)
+
+ if new_value != initial_value:
+ try:
+ if selection.value_type == 'Boolean':
+ # if the value's a boolean then allow for 'true' and 'false' inputs
+
+ if new_value.lower() == 'true':
+ new_value = '1'
+ elif new_value.lower() == 'false':
+ new_value = '0'
+ elif selection.value_type == 'LineList':
+ new_value = new_value.split(',') # set_conf accepts list inputs
+
+ tor_controller().set_conf(selection.name, new_value)
+ self.redraw(True)
+ except Exception as exc:
+ nyx.popups.show_msg('%s (press any key)' % exc)
+ elif key.match('a'):
+ self._show_all = not self._show_all
+ self.redraw(True)
+ elif key.match('s'):
+ self.show_sort_dialog()
+ elif key.match('w'):
+ self.show_write_dialog()
+ else:
+ return False
+
+ return True
+
+ def get_help(self):
+ return [
+ ('up arrow', 'scroll up a line', None),
+ ('down arrow', 'scroll down a line', None),
+ ('page up', 'scroll up a page', None),
+ ('page down', 'scroll down a page', None),
+ ('enter', 'edit configuration option', None),
+ ('w', 'write torrc', None),
+ ('a', 'toggle filtering', None),
+ ('s', 'sort ordering', None),
+ ]
+
+ def draw(self, width, height):
+ contents = self._get_config_options()
+ selection = self._scroller.get_cursor_selection(contents)
+ scroll_location = self._scroller.get_scroll_location(contents, height - DETAILS_HEIGHT)
+ is_scrollbar_visible = len(contents) > height - DETAILS_HEIGHT
+
+ if selection is not None:
+ self._draw_selection_details(selection, width)
+
+ if self.is_title_visible():
+ hidden_msg = "press 'a' to hide most options" if self._show_all else "press 'a' to show all options"
+ self.addstr(0, 0, 'Tor Configuration (%s):' % hidden_msg, curses.A_STANDOUT)
+
+ scroll_offset = 1
+
+ if is_scrollbar_visible:
+ scroll_offset = 3
+ self.add_scroll_bar(scroll_location, scroll_location + height - DETAILS_HEIGHT, len(contents), DETAILS_HEIGHT)
+
+ if selection is not None:
+ self.addch(DETAILS_HEIGHT - 1, 1, curses.ACS_TTEE)
+
+ # Description column can grow up to eighty characters. After that any extra
+ # space goes to the value.
+
+ description_width = max(0, width - scroll_offset - NAME_WIDTH - VALUE_WIDTH - 2)
+
+ if description_width > 80:
+ value_width = VALUE_WIDTH + (description_width - 80)
+ description_width = 80
+ else:
+ value_width = VALUE_WIDTH
+
+ for i, entry in enumerate(contents[scroll_location:]):
+ attr = nyx.util.ui_tools.get_color(CONFIG['attr.config.category_color'].get(entry.manual.category, 'white'))
+ attr |= curses.A_BOLD if entry.is_set() else curses.A_NORMAL
+ attr |= curses.A_STANDOUT if entry == selection else curses.A_NORMAL
+
+ option_label = str_tools.crop(entry.name, NAME_WIDTH).ljust(NAME_WIDTH + 1)
+ value_label = str_tools.crop(entry.value(), value_width).ljust(value_width + 1)
+ summary_label = str_tools.crop(entry.manual.summary, description_width).ljust(description_width)
+
+ self.addstr(DETAILS_HEIGHT + i, scroll_offset, option_label + value_label + summary_label, attr)
+
+ if DETAILS_HEIGHT + i >= height:
+ break
+
+ def _get_config_options(self):
+ return self._contents if self._show_all else filter(lambda entry: stem.manual.is_important(entry.name) or entry.is_set(), self._contents)
+
+ def _draw_selection_details(self, selection, width):
+ """
+ Shows details of the currently selected option.
+ """
+
+ description = 'Description: %s' % (selection.manual.description)
+ attr = ', '.join(('custom' if selection.is_set() else 'default', selection.value_type, 'usage: %s' % selection.manual.usage))
+ selected_color = CONFIG['attr.config.category_color'].get(selection.manual.category, 'white')
+ ui_tools.draw_box(self, 0, 0, width, DETAILS_HEIGHT)
+
+ self.addstr(1, 2, '%s (%s Option)' % (selection.name, selection.manual.category), curses.A_BOLD, selected_color)
+ self.addstr(2, 2, 'Value: %s (%s)' % (selection.value(), str_tools.crop(attr, width - len(selection.value()) - 13)), curses.A_BOLD, selected_color)
+
+ for i in range(DETAILS_HEIGHT - 4):
+ if not description:
+ break # done writing description
+
+ line, description = description.split('\n', 1) if '\n' in description else (description, '')
+
+ if i < DETAILS_HEIGHT - 5:
+ line, remainder = str_tools.crop(line, width - 3, 4, 4, str_tools.Ending.HYPHEN, True)
+ description = ' ' + remainder.strip() + description
+ self.addstr(3 + i, 2, line, curses.A_BOLD, selected_color)
+ else:
+ self.addstr(3 + i, 2, str_tools.crop(line, width - 3, 4, 4), curses.A_BOLD, selected_color)
diff --git a/nyx/panel/connection.py b/nyx/panel/connection.py
new file mode 100644
index 0000000..e28f531
--- /dev/null
+++ b/nyx/panel/connection.py
@@ -0,0 +1,706 @@
+"""
+Listing of the currently established connections tor has made.
+"""
+
+import re
+import time
+import collections
+import curses
+import itertools
+import threading
+
+import nyx.popups
+import nyx.util.tracker
+import nyx.util.ui_tools
+
+from nyx.util import panel, tor_controller, ui_tools
+
+from stem.control import Listener
+from stem.util import datetime_to_unix, conf, connection, enum, str_tools
+
+try:
+ # added in python 3.2
+ from functools import lru_cache
+except ImportError:
+ from stem.util.lru_cache import lru_cache
+
+# height of the detail panel content, not counting top and bottom border
+
+DETAILS_HEIGHT = 7
+
+EXIT_USAGE_WIDTH = 15
+UPDATE_RATE = 5 # rate in seconds at which we refresh
+
+# cached information from our last _update() call
+
+LAST_RETRIEVED_HS_CONF = None
+LAST_RETRIEVED_CIRCUITS = None
+
+# Connection Categories:
+# Inbound Relay connection, coming to us.
+# Outbound Relay connection, leaving us.
+# Exit Outbound relay connection leaving the Tor network.
+# Hidden Connections to a hidden service we're providing.
+# Socks Socks connections for applications using Tor.
+# Circuit Circuits our tor client has created.
+# Directory Fetching tor consensus information.
+# Control Tor controller (nyx, vidalia, etc).
+
+Category = enum.Enum('INBOUND', 'OUTBOUND', 'EXIT', 'HIDDEN', 'SOCKS', 'CIRCUIT', 'DIRECTORY', 'CONTROL')
+SortAttr = enum.Enum('CATEGORY', 'UPTIME', 'IP_ADDRESS', 'PORT', 'FINGERPRINT', 'NICKNAME', 'COUNTRY')
+LineType = enum.Enum('CONNECTION', 'CIRCUIT_HEADER', 'CIRCUIT')
+
+Line = collections.namedtuple('Line', [
+ 'entry',
+ 'line_type',
+ 'connection',
+ 'circuit',
+ 'fingerprint',
+ 'nickname',
+ 'locale',
+])
+
+
+def conf_handler(key, value):
+ if key == 'features.connection.order':
+ return conf.parse_enum_csv(key, value[0], SortAttr, 3)
+
+
+CONFIG = conf.config_dict('nyx', {
+ 'attr.connection.category_color': {},
+ 'attr.connection.sort_color': {},
+ 'features.connection.resolveApps': True,
+ 'features.connection.order': [SortAttr.CATEGORY, SortAttr.IP_ADDRESS, SortAttr.UPTIME],
+ 'features.connection.showIps': True,
+}, conf_handler)
+
+
+class Entry(object):
+ @staticmethod
+ @lru_cache()
+ def from_connection(connection):
+ return ConnectionEntry(connection)
+
+ @staticmethod
+ @lru_cache()
+ def from_circuit(circuit):
+ return CircuitEntry(circuit)
+
+ def get_lines(self):
+ """
+ Provides individual lines of connection information.
+
+ :returns: **list** of **ConnectionLine** concerning this entry
+ """
+
+ raise NotImplementedError('should be implemented by subclasses')
+
+ def get_type(self):
+ """
+ Provides our best guess at the type of connection this is.
+
+ :returns: **Category** for the connection's type
+ """
+
+ raise NotImplementedError('should be implemented by subclasses')
+
+ def is_private(self):
+ """
+ Checks if information about this endpoint should be scrubbed. Relaying
+ etiquette (and wiretapping laws) say these are bad things to look at so
+ DON'T CHANGE THIS UNLESS YOU HAVE A DAMN GOOD REASON!
+
+ :returns: **bool** indicating if connection information is sensive or not
+ """
+
+ raise NotImplementedError('should be implemented by subclasses')
+
+ def sort_value(self, attr):
+ """
+ Provides a heuristic for sorting by a given value.
+
+ :param SortAttr attr: sort attribute to provide a heuristic for
+
+ :returns: comparable value for sorting
+ """
+
+ line = self.get_lines()[0]
+ at_end = 'z' * 20
+
+ if attr == SortAttr.IP_ADDRESS:
+ if self.is_private():
+ return 255 ** 4 # orders at the end
+
+ ip_value = 0
+
+ for octet in line.connection.remote_address.split('.'):
+ ip_value = ip_value * 255 + int(octet)
+
+ return ip_value * 65536 + line.connection.remote_port
+ elif attr == SortAttr.PORT:
+ return line.connection.remote_port
+ elif attr == SortAttr.FINGERPRINT:
+ return line.fingerprint if line.fingerprint else at_end
+ elif attr == SortAttr.NICKNAME:
+ return line.nickname if line.nickname else at_end
+ elif attr == SortAttr.CATEGORY:
+ return Category.index_of(self.get_type())
+ elif attr == SortAttr.UPTIME:
+ return line.connection.start_time
+ elif attr == SortAttr.COUNTRY:
+ return line.locale if (line.locale and not self.is_private()) else at_end
+ else:
+ return ''
+
+
+class ConnectionEntry(Entry):
+ def __init__(self, connection):
+ self._connection = connection
+
+ @lru_cache()
+ def get_lines(self):
+ fingerprint, nickname, locale = None, None, None
+
+ if self.get_type() in (Category.OUTBOUND, Category.CIRCUIT, Category.DIRECTORY, Category.EXIT):
+ fingerprint = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(self._connection.remote_address).get(self._connection.remote_port)
+
+ if fingerprint:
+ nickname = nyx.util.tracker.get_consensus_tracker().get_relay_nickname(fingerprint)
+ locale = tor_controller().get_info('ip-to-country/%s' % self._connection.remote_address, None)
+
+ return [Line(self, LineType.CONNECTION, self._connection, None, fingerprint, nickname, locale)]
+
+ @lru_cache()
+ def get_type(self):
+ controller = tor_controller()
+
+ if self._connection.local_port in controller.get_ports(Listener.OR, []):
+ return Category.INBOUND
+ elif self._connection.local_port in controller.get_ports(Listener.DIR, []):
+ return Category.INBOUND
+ elif self._connection.local_port in controller.get_ports(Listener.SOCKS, []):
+ return Category.SOCKS
+ elif self._connection.local_port in controller.get_ports(Listener.CONTROL, []):
+ return Category.CONTROL
+
+ if LAST_RETRIEVED_HS_CONF:
+ for hs_config in LAST_RETRIEVED_HS_CONF.values():
+ if self._connection.remote_port == hs_config['HiddenServicePort']:
+ return Category.HIDDEN
+
+ fingerprint = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(self._connection.remote_address).get(self._connection.remote_port)
+
+ if fingerprint and LAST_RETRIEVED_CIRCUITS:
+ for circ in LAST_RETRIEVED_CIRCUITS:
+ if circ.path and len(circ.path) == 1 and circ.path[0][0] == fingerprint and circ.status == 'BUILT':
+ return Category.DIRECTORY # one-hop circuit to retrieve directory information
+ else:
+ # not a known relay, might be an exit connection
+
+ exit_policy = controller.get_exit_policy(None)
+
+ if exit_policy and exit_policy.can_exit_to(self._connection.remote_address, self._connection.remote_port):
+ return Category.EXIT
+
+ return Category.OUTBOUND
+
+ @lru_cache()
+ def is_private(self):
+ if not CONFIG['features.connection.showIps']:
+ return True
+
+ if self.get_type() == Category.INBOUND:
+ controller = tor_controller()
+
+ if controller.is_user_traffic_allowed().inbound:
+ return len(nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(self._connection.remote_address)) == 0
+ elif self.get_type() == Category.EXIT:
+ # DNS connections exiting us aren't private (since they're hitting our
+ # resolvers). Everything else is.
+
+ return not (self._connection.remote_port == 53 and self._connection.protocol == 'udp')
+
+ return False # for everything else this isn't a concern
+
+
+class CircuitEntry(Entry):
+ def __init__(self, circuit):
+ self._circuit = circuit
+
+ @lru_cache()
+ def get_lines(self):
+ def line(fingerprint, line_type):
+ address, port, nickname, locale = '0.0.0.0', 0, None, None
+ consensus_tracker = nyx.util.tracker.get_consensus_tracker()
+
+ if fingerprint is not None:
+ address, port = consensus_tracker.get_relay_address(fingerprint, ('192.168.0.1', 0))
+ nickname = consensus_tracker.get_relay_nickname(fingerprint)
+ locale = tor_controller().get_info('ip-to-country/%s' % address, None)
+
+ connection = nyx.util.tracker.Connection(datetime_to_unix(self._circuit.created), False, '127.0.0.1', 0, address, port, 'tcp', False)
+ return Line(self, line_type, connection, self._circuit, fingerprint, nickname, locale)
+
+ header_line = line(self._circuit.path[-1][0] if self._circuit.status == 'BUILT' else None, LineType.CIRCUIT_HEADER)
+ return [header_line] + [line(fp, LineType.CIRCUIT) for fp, _ in self._circuit.path]
+
+ def get_type(self):
+ return Category.CIRCUIT
+
+ def is_private(self):
+ return False
+
+
+class ConnectionPanel(panel.Panel, threading.Thread):
+ """
+ Listing of connections tor is making, with information correlated against
+ the current consensus and other data sources.
+ """
+
+ def __init__(self, stdscr):
+ panel.Panel.__init__(self, stdscr, 'connections', 0)
+ threading.Thread.__init__(self)
+ self.setDaemon(True)
+
+ self._scroller = ui_tools.Scroller(True)
+ self._entries = [] # last fetched display entries
+ self._show_details = False # presents the details panel if true
+ self._sort_order = CONFIG['features.connection.order']
+
+ self._last_resource_fetch = -1 # timestamp of the last ConnectionResolver results used
+
+ self._pause_condition = threading.Condition()
+ self._halt = False # terminates thread if true
+
+ # Tracks exiting port and client country statistics
+
+ self._client_locale_usage = {}
+ self._exit_port_usage = {}
+ self._counted_connections = set()
+
+ # If we're a bridge and been running over a day then prepopulates with the
+ # last day's clients.
+
+ bridge_clients = tor_controller().get_info('status/clients-seen', None)
+
+ if bridge_clients:
+ # Response has a couple arguments...
+ # TimeStarted="2011-08-17 15:50:49" CountrySummary=us=16,de=8,uk=8
+
+ country_summary = None
+
+ for line in bridge_clients.split():
+ if line.startswith('CountrySummary='):
+ country_summary = line[15:]
+ break
+
+ if country_summary:
+ for entry in country_summary.split(','):
+ if re.match('^..=[0-9]+$', entry):
+ locale, count = entry.split('=', 1)
+ self._client_locale_usage[locale] = int(count)
+
+ def show_sort_dialog(self):
+ """
+ Provides a dialog for sorting our connections.
+ """
+
+ sort_colors = dict([(attr, CONFIG['attr.connection.sort_color'].get(attr, 'white')) for attr in SortAttr])
+ results = nyx.popups.show_sort_dialog('Connection Ordering:', SortAttr, self._sort_order, sort_colors)
+
+ if results:
+ self._sort_order = results
+ self._entries = sorted(self._entries, key = lambda entry: [entry.sort_value(attr) for attr in self._sort_order])
+
+ def handle_key(self, key):
+ user_traffic_allowed = tor_controller().is_user_traffic_allowed()
+
+ if key.is_scroll():
+ page_height = self.get_preferred_size()[0] - 1
+
+ if self._show_details:
+ page_height -= (DETAILS_HEIGHT + 1)
+
+ lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in self._entries]))
+ is_changed = self._scroller.handle_key(key, lines, page_height)
+
+ if is_changed:
+ self.redraw(True)
+ elif key.is_selection():
+ self._show_details = not self._show_details
+ self.redraw(True)
+ elif key.match('s'):
+ self.show_sort_dialog()
+ elif key.match('r'):
+ connection_tracker = nyx.util.tracker.get_connection_tracker()
+ options = ['auto'] + list(connection.Resolver) + list(nyx.util.tracker.CustomResolver)
+
+ resolver = connection_tracker.get_custom_resolver()
+ selected_index = 0 if resolver is None else options.index(resolver)
+ selection = nyx.popups.show_menu('Connection Resolver:', options, selected_index)
+
+ if selection != -1:
+ connection_tracker.set_custom_resolver(None if selection == 0 else options[selection])
+ elif key.match('d'):
+ self.set_title_visible(False)
+ self.redraw(True)
+ entries = self._entries
+
+ while True:
+ lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in entries]))
+ selection = self._scroller.get_cursor_selection(lines)
+
+ if not selection:
+ break
+
+ def is_close_key(key):
+ return key.is_selection() or key.match('d') or key.match('left') or key.match('right')
+
+ color = CONFIG['attr.connection.category_color'].get(selection.entry.get_type(), 'white')
+ key = nyx.popups.show_descriptor_popup(selection.fingerprint, color, self.max_x, is_close_key)
+
+ if not key or key.is_selection() or key.match('d'):
+ break # closes popup
+ elif key.match('left'):
+ self.handle_key(panel.KeyInput(curses.KEY_UP))
+ elif key.match('right'):
+ self.handle_key(panel.KeyInput(curses.KEY_DOWN))
+
+ self.set_title_visible(True)
+ self.redraw(True)
+ elif key.match('c') and user_traffic_allowed.inbound:
+ nyx.popups.show_count_dialog('Client Locales', self._client_locale_usage)
+ elif key.match('e') and user_traffic_allowed.outbound:
+ counts = {}
+ key_width = max(map(len, self._exit_port_usage.keys()))
+
+ for k, v in self._exit_port_usage.items():
+ usage = connection.port_usage(k)
+
+ if usage:
+ k = k.ljust(key_width + 3) + usage.ljust(EXIT_USAGE_WIDTH)
+
+ counts[k] = v
+
+ nyx.popups.show_count_dialog('Exiting Port Usage', counts)
+ else:
+ return False
+
+ return True
+
+ def run(self):
+ """
+ Keeps connections listing updated, checking for new entries at a set rate.
+ """
+
+ last_ran = -1
+
+ while not self._halt:
+ if self.is_paused() or not tor_controller().is_alive() or (time.time() - last_ran) < UPDATE_RATE:
+ with self._pause_condition:
+ if not self._halt:
+ self._pause_condition.wait(0.2)
+
+ continue # done waiting, try again
+
+ self._update()
+ self.redraw(True)
+
+ # If this is our first run then fill in our fingerprint tracker. This
+ # requires fetching all the router status entries which takes a few
+ # seconds, so best done when we're finished with the rest of the first
+ # iteration to hide the lag.
+
+ if last_ran == -1:
+ nyx.util.tracker.get_consensus_tracker().update(tor_controller().get_network_statuses([]))
+
+ last_ran = time.time()
+
+ def get_help(self):
+ resolver = nyx.util.tracker.get_connection_tracker().get_custom_resolver()
+ user_traffic_allowed = tor_controller().is_user_traffic_allowed()
+
+ options = [
+ ('up arrow', 'scroll up a line', None),
+ ('down arrow', 'scroll down a line', None),
+ ('page up', 'scroll up a page', None),
+ ('page down', 'scroll down a page', None),
+ ('enter', 'show connection details', None),
+ ('d', 'raw consensus descriptor', None),
+ ('s', 'sort ordering', None),
+ ('r', 'connection resolver', 'auto' if resolver is None else resolver),
+ ]
+
+ if user_traffic_allowed.inbound:
+ options.append(('c', 'client locale usage summary', None))
+
+ if user_traffic_allowed.outbound:
+ options.append(('e', 'exit port usage summary', None))
+
+ return options
+
+ def draw(self, width, height):
+ controller = tor_controller()
+ entries = self._entries
+
+ lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in entries]))
+ selected = self._scroller.get_cursor_selection(lines)
+
+ if self.is_paused():
+ current_time = self.get_pause_time()
+ elif not controller.is_alive():
+ current_time = controller.connection_time()
+ else:
+ current_time = time.time()
+
+ is_showing_details = self._show_details and selected
+ details_offset = DETAILS_HEIGHT + 1 if is_showing_details else 0
+
+ is_scrollbar_visible = len(lines) > height - details_offset - 1
+ scroll_offset = 2 if is_scrollbar_visible else 0
+ scroll_location = self._scroller.get_scroll_location(lines, height - details_offset - 1)
+
+ if self.is_title_visible():
+ self._draw_title(entries, self._show_details)
+
+ if is_showing_details:
+ self._draw_details(selected, width, is_scrollbar_visible)
+
+ if is_scrollbar_visible:
+ self.add_scroll_bar(scroll_location, scroll_location + height - details_offset - 1, len(lines), 1 + details_offset)
+
+ for line_number in range(scroll_location, len(lines)):
+ y = line_number + details_offset + 1 - scroll_location
+ self._draw_line(scroll_offset, y, lines[line_number], lines[line_number] == selected, width - scroll_offset, current_time)
+
+ if y >= height:
+ break
+
+ def _draw_title(self, entries, showing_details):
+ """
+ Panel title with the number of connections we presently have.
+ """
+
+ if showing_details:
+ self.addstr(0, 0, 'Connection Details:', curses.A_STANDOUT)
+ elif not entries:
+ self.addstr(0, 0, 'Connections:', curses.A_STANDOUT)
+ else:
+ counts = collections.Counter([entry.get_type() for entry in entries])
+ count_labels = ['%i %s' % (counts[category], category.lower()) for category in Category if counts[category]]
+ self.addstr(0, 0, 'Connections (%s):' % ', '.join(count_labels), curses.A_STANDOUT)
+
+ def _draw_details(self, selected, width, is_scrollbar_visible):
+ """
+ Shows detailed information about the selected connection.
+ """
+
+ attr = (CONFIG['attr.connection.category_color'].get(selected.entry.get_type(), 'white'), curses.A_BOLD)
+
+ if selected.line_type == LineType.CIRCUIT_HEADER and selected.circuit.status != 'BUILT':
+ self.addstr(1, 2, 'Building Circuit...', *attr)
+ else:
+ address = '<scrubbed>' if selected.entry.is_private() else selected.connection.remote_address
+ self.addstr(1, 2, 'address: %s:%s' % (address, selected.connection.remote_port), *attr)
+ self.addstr(2, 2, 'locale: %s' % ('??' if selected.entry.is_private() else (selected.locale if selected.locale else '??')), *attr)
+
+ matches = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprints(selected.connection.remote_address)
+
+ if not matches:
+ self.addstr(3, 2, 'No consensus data found', *attr)
+ elif len(matches) == 1 or selected.connection.remote_port in matches:
+ controller = tor_controller()
+ fingerprint = matches.values()[0] if len(matches) == 1 else matches[selected.connection.remote_port]
+ router_status_entry = controller.get_network_status(fingerprint, None)
+
+ self.addstr(2, 15, 'fingerprint: %s' % fingerprint, *attr)
+
+ if router_status_entry:
+ dir_port_label = 'dirport: %s' % router_status_entry.dir_port if router_status_entry.dir_port else ''
+ self.addstr(3, 2, 'nickname: %-25s orport: %-10s %s' % (router_status_entry.nickname, router_status_entry.or_port, dir_port_label), *attr)
+ self.addstr(4, 2, 'published: %s' % router_status_entry.published.strftime("%H:%M %m/%d/%Y"), *attr)
+ self.addstr(5, 2, 'flags: %s' % ', '.join(router_status_entry.flags), *attr)
+
+ server_descriptor = controller.get_server_descriptor(fingerprint, None)
+
+ if server_descriptor:
+ policy_label = server_descriptor.exit_policy.summary() if server_descriptor.exit_policy else 'unknown'
+ self.addstr(6, 2, 'exit policy: %s' % policy_label, *attr)
+ self.addstr(4, 38, 'os: %-14s version: %s' % (server_descriptor.operating_system, server_descriptor.tor_version), *attr)
+
+ if server_descriptor.contact:
+ self.addstr(7, 2, 'contact: %s' % server_descriptor.contact, *attr)
+ else:
+ self.addstr(3, 2, 'Multiple matches, possible fingerprints are:', *attr)
+
+ for i, port in enumerate(sorted(matches.keys())):
+ is_last_line, remaining_relays = i == 3, len(matches) - i
+
+ if not is_last_line or remaining_relays == 1:
+ self.addstr(4 + i, 2, '%i. or port: %-5s fingerprint: %s' % (i + 1, port, matches[port]), *attr)
+ else:
+ self.addstr(4 + i, 2, '... %i more' % remaining_relays, *attr)
+
+ if is_last_line:
+ break
+
+ # draw the border, with a 'T' pipe if connecting with the scrollbar
+
+ ui_tools.draw_box(self, 0, 0, width, DETAILS_HEIGHT + 2)
+
+ if is_scrollbar_visible:
+ self.addch(DETAILS_HEIGHT + 1, 1, curses.ACS_TTEE)
+
+ def _draw_line(self, x, y, line, is_selected, width, current_time):
+ attr = nyx.util.ui_tools.get_color(CONFIG['attr.connection.category_color'].get(line.entry.get_type(), 'white'))
+ attr |= curses.A_STANDOUT if is_selected else curses.A_NORMAL
+
+ self.addstr(y, x, ' ' * (width - x), attr)
+
+ if line.line_type == LineType.CIRCUIT:
+ if line.circuit.path[-1][0] == line.fingerprint:
+ prefix = (ord(' '), curses.ACS_LLCORNER, curses.ACS_HLINE, ord(' '))
+ else:
+ prefix = (ord(' '), curses.ACS_VLINE, ord(' '), ord(' '))
+
+ for char in prefix:
+ x = self.addch(y, x, char)
+ else:
+ x += 1 # offset from edge
+
+ self._draw_address_column(x, y, line, attr)
+ self._draw_line_details(57, y, line, width - 57 - 20, attr)
+ self._draw_right_column(width - 18, y, line, current_time, attr)
+
+ def _draw_address_column(self, x, y, line, attr):
+ src = tor_controller().get_info('address', line.connection.local_address)
+ src += ':%s' % line.connection.local_port if line.line_type == LineType.CONNECTION else ''
+
+ if line.line_type == LineType.CIRCUIT_HEADER and line.circuit.status != 'BUILT':
+ dst = 'Building...'
+ else:
+ dst = '<scrubbed>' if line.entry.is_private() else line.connection.remote_address
+ dst += ':%s' % line.connection.remote_port
+
+ if line.entry.get_type() == Category.EXIT:
+ purpose = connection.port_usage(line.connection.remote_port)
+
+ if purpose:
+ dst += ' (%s)' % str_tools.crop(purpose, 26 - len(dst) - 3)
+ elif not tor_controller().is_geoip_unavailable() and not line.entry.is_private():
+ dst += ' (%s)' % (line.locale if line.locale else '??')
+
+ if line.entry.get_type() in (Category.INBOUND, Category.SOCKS, Category.CONTROL):
+ dst, src = src, dst
+
+ if line.line_type == LineType.CIRCUIT:
+ self.addstr(y, x, dst, attr)
+ else:
+ self.addstr(y, x, '%-21s --> %-26s' % (src, dst), attr)
+
+ def _draw_line_details(self, x, y, line, width, attr):
+ if line.line_type == LineType.CIRCUIT_HEADER:
+ comp = ['Purpose: %s' % line.circuit.purpose.capitalize(), ', Circuit ID: %s' % line.circuit.id]
+ elif line.entry.get_type() in (Category.SOCKS, Category.HIDDEN, Category.CONTROL):
+ try:
+ port = line.connection.local_port if line.entry.get_type() == Category.HIDDEN else line.connection.remote_port
+ process = nyx.util.tracker.get_port_usage_tracker().fetch(port)
+ comp = ['%s (%s)' % (process.name, process.pid) if process.pid else process.name]
+ except nyx.util.tracker.UnresolvedResult:
+ comp = ['resolving...']
+ except nyx.util.tracker.UnknownApplication:
+ comp = ['UNKNOWN']
+ else:
+ comp = ['%-40s' % (line.fingerprint if line.fingerprint else 'UNKNOWN'), ' ' + (line.nickname if line.nickname else 'UNKNOWN')]
+
+ for entry in comp:
+ if width >= x + len(entry):
+ x = self.addstr(y, x, entry, attr)
+ else:
+ return
+
+ def _draw_right_column(self, x, y, line, current_time, attr):
+ if line.line_type == LineType.CIRCUIT:
+ circ_path = [fp for fp, _ in line.circuit.path]
+ circ_index = circ_path.index(line.fingerprint)
+
+ if circ_index == len(circ_path) - 1:
+ placement_type = 'Exit' if line.circuit.status == 'BUILT' else 'Extending'
+ elif circ_index == 0:
+ placement_type = 'Guard'
+ else:
+ placement_type = 'Middle'
+
+ self.addstr(y, x + 4, '%i / %s' % (circ_index + 1, placement_type), attr)
+ else:
+ x = self.addstr(y, x, '+' if line.connection.is_legacy else ' ', attr)
+ x = self.addstr(y, x, '%5s' % str_tools.time_label(current_time - line.connection.start_time, 1), attr)
+ x = self.addstr(y, x, ' (', attr)
+ x = self.addstr(y, x, line.entry.get_type().upper(), attr | curses.A_BOLD)
+ x = self.addstr(y, x, ')', attr)
+
+ def stop(self):
+ """
+ Halts further resolutions and terminates the thread.
+ """
+
+ with self._pause_condition:
+ self._halt = True
+ self._pause_condition.notifyAll()
+
+ def _update(self):
+ """
+ Fetches the newest resolved connections.
+ """
+
+ global LAST_RETRIEVED_CIRCUITS, LAST_RETRIEVED_HS_CONF
+
+ controller = tor_controller()
+ LAST_RETRIEVED_CIRCUITS = controller.get_circuits([])
+ LAST_RETRIEVED_HS_CONF = controller.get_hidden_service_conf({})
+
+ conn_resolver = nyx.util.tracker.get_connection_tracker()
+ current_resolution_count = conn_resolver.run_counter()
+
+ if not conn_resolver.is_alive():
+ return # if we're not fetching connections then this is a no-op
+ elif current_resolution_count == self._last_resource_fetch:
+ return # no new connections to process
+
+ new_entries = [Entry.from_connection(conn) for conn in conn_resolver.get_value()]
+
+ for circ in LAST_RETRIEVED_CIRCUITS:
+ # Skips established single-hop circuits (these are for directory
+ # fetches, not client circuits)
+
+ if not (circ.status == 'BUILT' and len(circ.path) == 1):
+ new_entries.append(Entry.from_circuit(circ))
+
+ # update stats for client and exit connections
+
+ for entry in new_entries:
+ line = entry.get_lines()[0]
+
+ if entry.is_private() and line.connection not in self._counted_connections:
+ if entry.get_type() == Category.INBOUND and line.locale:
+ self._client_locale_usage[line.locale] = self._client_locale_usage.get(line.locale, 0) + 1
+ elif entry.get_type() == Category.EXIT:
+ self._exit_port_usage[line.connection.remote_port] = self._exit_port_usage.get(line.connection.remote_port, 0) + 1
+
+ self._counted_connections.add(line.connection)
+
+ self._entries = sorted(new_entries, key = lambda entry: [entry.sort_value(attr) for attr in self._sort_order])
+ self._last_resource_fetch = current_resolution_count
+
+ if CONFIG['features.connection.resolveApps']:
+ local_ports, remote_ports = [], []
+
+ for entry in new_entries:
+ line = entry.get_lines()[0]
+
+ if entry.get_type() in (Category.SOCKS, Category.CONTROL):
+ local_ports.append(line.connection.remote_port)
+ elif entry.get_type() == Category.HIDDEN:
+ remote_ports.append(line.connection.local_port)
+
+ nyx.util.tracker.get_port_usage_tracker().query(local_ports, remote_ports)
diff --git a/nyx/panel/graph.py b/nyx/panel/graph.py
new file mode 100644
index 0000000..086d04d
--- /dev/null
+++ b/nyx/panel/graph.py
@@ -0,0 +1,753 @@
+"""
+Graphs of tor related statistics. For example...
+
+Downloaded (0.0 B/sec): Uploaded (0.0 B/sec):
+ 34 30
+ * *
+ ** * * * **
+ * * * ** ** ** *** ** ** ** **
+ ********* ****** ****** ********* ****** ******
+ 0 ************ **************** 0 ************ ****************
+ 25s 50 1m 1.6 2.0 25s 50 1m 1.6 2.0
+"""
+
+import collections
+import copy
+import curses
+import time
+
+import nyx.controller
+import nyx.popups
+import nyx.util.tracker
+
+from stem.control import EventType, Listener
+from stem.util import conf, enum, log, str_tools, system
+from nyx.util import join, msg, panel, tor_controller
+
+GraphStat = enum.Enum(('BANDWIDTH', 'bandwidth'), ('CONNECTIONS', 'connections'), ('SYSTEM_RESOURCES', 'resources'))
+Interval = enum.Enum(('EACH_SECOND', 'each second'), ('FIVE_SECONDS', '5 seconds'), ('THIRTY_SECONDS', '30 seconds'), ('MINUTELY', 'minutely'), ('FIFTEEN_MINUTE', '15 minute'), ('THIRTY_MINUTE', '30 minute'), ('HOURLY', 'hourly'), ('DAILY', 'daily'))
+Bounds = enum.Enum(('GLOBAL_MAX', 'global_max'), ('LOCAL_MAX', 'local_max'), ('TIGHT', 'tight'))
+
+DrawAttributes = collections.namedtuple('DrawAttributes', ('stat', 'subgraph_height', 'subgraph_width', 'interval', 'bounds_type', 'accounting'))
+
+INTERVAL_SECONDS = {
+ Interval.EACH_SECOND: 1,
+ Interval.FIVE_SECONDS: 5,
+ Interval.THIRTY_SECONDS: 30,
+ Interval.MINUTELY: 60,
+ Interval.FIFTEEN_MINUTE: 900,
+ Interval.THIRTY_MINUTE: 1800,
+ Interval.HOURLY: 3600,
+ Interval.DAILY: 86400,
+}
+
+PRIMARY_COLOR, SECONDARY_COLOR = 'green', 'cyan'
+
+ACCOUNTING_RATE = 5
+DEFAULT_CONTENT_HEIGHT = 4 # space needed for labeling above and below the graph
+WIDE_LABELING_GRAPH_COL = 50 # minimum graph columns to use wide spacing for x-axis labels
+COLLAPSE_WIDTH = 135 # width at which to move optional stats from the title to x-axis label
+
+
+def conf_handler(key, value):
+ if key == 'features.graph.height':
+ return max(1, value)
+ elif key == 'features.graph.max_width':
+ return max(1, value)
+ elif key == 'features.graph.type':
+ if value != 'none' and value not in GraphStat:
+ log.warn("'%s' isn't a valid graph type, options are: none, %s" % (CONFIG['features.graph.type'], ', '.join(GraphStat)))
+ return CONFIG['features.graph.type'] # keep the default
+ elif key == 'features.graph.interval':
+ if value not in Interval:
+ log.warn("'%s' isn't a valid graphing interval, options are: %s" % (value, ', '.join(Interval)))
+ return CONFIG['features.graph.interval'] # keep the default
+ elif key == 'features.graph.bound':
+ if value not in Bounds:
+ log.warn("'%s' isn't a valid graph bounds, options are: %s" % (value, ', '.join(Bounds)))
+ return CONFIG['features.graph.bound'] # keep the default
+
+
+CONFIG = conf.config_dict('nyx', {
+ 'attr.hibernate_color': {},
+ 'attr.graph.title': {},
+ 'attr.graph.header.primary': {},
+ 'attr.graph.header.secondary': {},
+ 'features.graph.height': 7,
+ 'features.graph.type': GraphStat.BANDWIDTH,
+ 'features.graph.interval': Interval.EACH_SECOND,
+ 'features.graph.bound': Bounds.LOCAL_MAX,
+ 'features.graph.max_width': 300, # we need some sort of max size so we know how much graph data to retain
+ 'features.panels.show.connection': True,
+ 'features.graph.bw.transferInBytes': False,
+ 'features.graph.bw.accounting.show': True,
+}, conf_handler)
+
+
+class GraphData(object):
+ """
+ Graphable statistical information.
+
+ :var int latest_value: last value we recorded
+ :var int total: sum of all values we've recorded
+ :var int tick: number of events we've processed
+ :var dict values: mapping of intervals to an array of samplings from newest to oldest
+ :var dict max_value: mapping of intervals to the maximum value it has had
+ """
+
+ def __init__(self, clone = None, category = None, is_primary = True):
+ if clone:
+ self.latest_value = clone.latest_value
+ self.total = clone.total
+ self.tick = clone.tick
+ self.values = copy.deepcopy(clone.values)
+ self.max_value = dict(clone.max_value)
+
+ self._category = clone._category
+ self._is_primary = clone._is_primary
+ self._in_process_value = dict(clone._in_process_value)
+ else:
+ self.latest_value = 0
+ self.total = 0
+ self.tick = 0
+ self.values = dict([(i, CONFIG['features.graph.max_width'] * [0]) for i in Interval])
+ self.max_value = dict([(i, 0) for i in Interval])
+
+ self._category = category
+ self._is_primary = is_primary
+ self._in_process_value = dict([(i, 0) for i in Interval])
+
+ def average(self):
+ return self.total / max(1, self.tick)
+
+ def update(self, new_value):
+ self.latest_value = new_value
+ self.total += new_value
+ self.tick += 1
+
+ for interval in Interval:
+ interval_seconds = INTERVAL_SECONDS[interval]
+ self._in_process_value[interval] += new_value
+
+ if self.tick % interval_seconds == 0:
+ new_entry = self._in_process_value[interval] / interval_seconds
+ self.values[interval] = [new_entry] + self.values[interval][:-1]
+ self.max_value[interval] = max(self.max_value[interval], new_entry)
+ self._in_process_value[interval] = 0
+
+ def header(self, width):
+ """
+ Provides the description above a subgraph.
+
+ :param int width: maximum length of the header
+
+ :returns: **str** with our graph header
+ """
+
+ return self._category._header(width, self._is_primary)
+
+ def y_axis_label(self, value):
+ """
+ Provides the label we should display on our y-axis.
+
+ :param int value: value being shown on the y-axis
+
+ :returns: **str** with our y-axis label
+ """
+
+ return self._category._y_axis_label(value, self._is_primary)
+
+
+class GraphCategory(object):
+ """
+ Category for the graph. This maintains two subgraphs, updating them each
+ second with updated stats.
+
+ :var GraphData primary: first subgraph
+ :var GraphData secondary: second subgraph
+ :var float start_time: unix timestamp for when we started
+ """
+
+ def __init__(self, clone = None):
+ if clone:
+ self.primary = GraphData(clone.primary)
+ self.secondary = GraphData(clone.secondary)
+ self.start_time = clone.start_time
+ self._title_stats = list(clone._title_stats)
+ self._primary_header_stats = list(clone._primary_header_stats)
+ self._secondary_header_stats = list(clone._secondary_header_stats)
+ else:
+ self.primary = GraphData(category = self, is_primary = True)
+ self.secondary = GraphData(category = self, is_primary = False)
+ self.start_time = time.time()
+ self._title_stats = []
+ self._primary_header_stats = []
+ self._secondary_header_stats = []
+
+ def stat_type(self):
+ """
+ Provides the GraphStat this graph is for.
+
+ :returns: **GraphStat** of this graph
+ """
+
+ raise NotImplementedError('Should be implemented by subclasses')
+
+ def title(self, width):
+ """
+ Provides a graph title that fits in the given width.
+
+ :param int width: maximum length of the title
+
+ :returns: **str** with our title
+ """
+
+ title = CONFIG['attr.graph.title'].get(self.stat_type(), '')
+ title_stats = join(self._title_stats, ', ', width - len(title) - 4)
+ return '%s (%s):' % (title, title_stats) if title_stats else title + ':'
+
+ def bandwidth_event(self, event):
+ """
+ Called when it's time to process another event. All graphs use tor BW
+ events to keep in sync with each other (this happens once per second).
+ """
+
+ pass
+
+ def _header(self, is_primary, width):
+ if is_primary:
+ header = CONFIG['attr.graph.header.primary'].get(self.stat_type(), '')
+ header_stats = self._primary_header_stats
+ else:
+ header = CONFIG['attr.graph.header.secondary'].get(self.stat_type(), '')
+ header_stats = self._secondary_header_stats
+
+ header_stats = join(header_stats, '', width - len(header) - 4)
+ return '%s (%s):' % (header, header_stats) if header_stats else '%s:' % header
+
+ def _y_axis_label(self, value, is_primary):
+ return str(value)
+
+
+class BandwidthStats(GraphCategory):
+ """
+ Tracks tor's bandwidth usage.
+ """
+
+ def __init__(self, clone = None):
+ GraphCategory.__init__(self, clone)
+
+ if not clone:
+ # fill in past bandwidth information
+
+ controller = tor_controller()
+ bw_entries, is_successful = controller.get_info('bw-event-cache', None), True
+
+ if bw_entries:
+ for entry in bw_entries.split():
+ entry_comp = entry.split(',')
+
+ if len(entry_comp) != 2 or not entry_comp[0].isdigit() or not entry_comp[1].isdigit():
+ log.warn(msg('panel.graphing.bw_event_cache_malformed', response = bw_entries))
+ is_successful = False
+ break
+
+ self.primary.update(int(entry_comp[0]))
+ self.secondary.update(int(entry_comp[1]))
+
+ if is_successful:
+ log.info(msg('panel.graphing.prepopulation_successful', duration = str_tools.time_label(len(bw_entries.split()), is_long = True)))
+
+ read_total = controller.get_info('traffic/read', None)
+ write_total = controller.get_info('traffic/written', None)
+ start_time = system.start_time(controller.get_pid(None))
+
+ if read_total and write_total and start_time:
+ self.primary.total = int(read_total)
+ self.secondary.total = int(write_total)
+ self.start_time = start_time
+
+ def stat_type(self):
+ return GraphStat.BANDWIDTH
+
+ def _y_axis_label(self, value, is_primary):
+ return _size_label(value, 0)
+
+ def bandwidth_event(self, event):
+ self.primary.update(event.read)
+ self.secondary.update(event.written)
+
+ self._primary_header_stats = [
+ '%-14s' % ('%s/sec' % _size_label(self.primary.latest_value)),
+ '- avg: %s/sec' % _size_label(self.primary.total / (time.time() - self.start_time)),
+ ', total: %s' % _size_label(self.primary.total),
+ ]
+
+ self._secondary_header_stats = [
+ '%-14s' % ('%s/sec' % _size_label(self.secondary.latest_value)),
+ '- avg: %s/sec' % _size_label(self.secondary.total / (time.time() - self.start_time)),
+ ', total: %s' % _size_label(self.secondary.total),
+ ]
+
+ controller = tor_controller()
+
+ stats = []
+ bw_rate = controller.get_effective_rate(None)
+ bw_burst = controller.get_effective_rate(None, burst = True)
+
+ if bw_rate and bw_burst:
+ bw_rate_label = _size_label(bw_rate)
+ bw_burst_label = _size_label(bw_burst)
+
+ # if both are using rounded values then strip off the '.0' decimal
+
+ if '.0' in bw_rate_label and '.0' in bw_burst_label:
+ bw_rate_label = bw_rate_label.split('.', 1)[0]
+ bw_burst_label = bw_burst_label.split('.', 1)[0]
+
+ stats.append('limit: %s/s' % bw_rate_label)
+ stats.append('burst: %s/s' % bw_burst_label)
+
+ my_router_status_entry = controller.get_network_status(default = None)
+ measured_bw = getattr(my_router_status_entry, 'bandwidth', None)
+
+ if measured_bw:
+ stats.append('measured: %s/s' % _size_label(measured_bw))
+ else:
+ my_server_descriptor = controller.get_server_descriptor(default = None)
+ observed_bw = getattr(my_server_descriptor, 'observed_bandwidth', None)
+
+ if observed_bw:
+ stats.append('observed: %s/s' % _size_label(observed_bw))
+
+ self._title_stats = stats
+
+
+class ConnectionStats(GraphCategory):
+ """
+ Tracks number of inbound and outbound connections.
+ """
+
+ def stat_type(self):
+ return GraphStat.CONNECTIONS
+
+ def bandwidth_event(self, event):
+ inbound_count, outbound_count = 0, 0
+
+ controller = tor_controller()
+ or_ports = controller.get_ports(Listener.OR, [])
+ dir_ports = controller.get_ports(Listener.DIR, [])
+ control_ports = controller.get_ports(Listener.CONTROL, [])
+
+ for entry in nyx.util.tracker.get_connection_tracker().get_value():
+ if entry.local_port in or_ports or entry.local_port in dir_ports:
+ inbound_count += 1
+ elif entry.local_port in control_ports:
+ pass # control connection
+ else:
+ outbound_count += 1
+
+ self.primary.update(inbound_count)
+ self.secondary.update(outbound_count)
+
+ self._primary_header_stats = [str(self.primary.latest_value), ', avg: %s' % self.primary.average()]
+ self._secondary_header_stats = [str(self.secondary.latest_value), ', avg: %s' % self.secondary.average()]
+
+
+class ResourceStats(GraphCategory):
+ """
+ Tracks cpu and memory usage of the tor process.
+ """
+
+ def stat_type(self):
+ return GraphStat.SYSTEM_RESOURCES
+
+ def _y_axis_label(self, value, is_primary):
+ return '%i%%' % value if is_primary else str_tools.size_label(value)
+
+ def bandwidth_event(self, event):
+ resources = nyx.util.tracker.get_resource_tracker().get_value()
+ self.primary.update(resources.cpu_sample * 100) # decimal percentage to whole numbers
+ self.secondary.update(resources.memory_bytes)
+
+ self._primary_header_stats = ['%0.1f%%' % self.primary.latest_value, ', avg: %0.1f%%' % self.primary.average()]
+ self._secondary_header_stats = [str_tools.size_label(self.secondary.latest_value, 1), ', avg: %s' % str_tools.size_label(self.secondary.average(), 1)]
+
+
+class GraphPanel(panel.Panel):
+ """
+ Panel displaying graphical information of GraphCategory instances.
+ """
+
+ def __init__(self, stdscr):
+ panel.Panel.__init__(self, stdscr, 'graph', 0)
+
+ self._displayed_stat = None if CONFIG['features.graph.type'] == 'none' else CONFIG['features.graph.type']
+ self._update_interval = CONFIG['features.graph.interval']
+ self._bounds = CONFIG['features.graph.bound']
+ self._graph_height = CONFIG['features.graph.height']
+
+ self._accounting_stats = None
+
+ self._stats = {
+ GraphStat.BANDWIDTH: BandwidthStats(),
+ GraphStat.SYSTEM_RESOURCES: ResourceStats(),
+ }
+
+ if CONFIG['features.panels.show.connection']:
+ self._stats[GraphStat.CONNECTIONS] = ConnectionStats()
+ elif self._displayed_stat == GraphStat.CONNECTIONS:
+ log.warn("The connection graph is unavailble when you set 'features.panels.show.connection false'.")
+ self._displayed_stat = GraphStat.BANDWIDTH
+
+ self.set_pause_attr('_stats')
+ self.set_pause_attr('_accounting_stats')
+
+ controller = tor_controller()
+ controller.add_event_listener(self._update_accounting, EventType.BW)
+ controller.add_event_listener(self._update_stats, EventType.BW)
+ controller.add_status_listener(lambda *args: self.redraw(True))
+
+ @property
+ def displayed_stat(self):
+ return self._displayed_stat
+
+ @displayed_stat.setter
+ def displayed_stat(self, value):
+ if value is not None and value not in self._stats.keys():
+ raise ValueError("%s isn't a graphed statistic" % value)
+
+ self._displayed_stat = value
+
+ def stat_options(self):
+ return self._stats.keys()
+
+ @property
+ def update_interval(self):
+ return self._update_interval
+
+ @update_interval.setter
+ def update_interval(self, value):
+ if value not in Interval:
+ raise ValueError("%s isn't a valid graphing update interval" % value)
+
+ self._update_interval = value
+
+ @property
+ def bounds_type(self):
+ return self._bounds
+
+ @bounds_type.setter
+ def bounds_type(self, value):
+ if value not in Bounds:
+ raise ValueError("%s isn't a valid type of bounds" % value)
+
+ self._bounds = value
+
+ def get_height(self):
+ """
+ Provides the height of the content.
+ """
+
+ if not self.displayed_stat:
+ return 0
+
+ height = DEFAULT_CONTENT_HEIGHT + self._graph_height
+
+ if self.displayed_stat == GraphStat.BANDWIDTH and self._accounting_stats:
+ height += 3
+
+ return height
+
+ def set_graph_height(self, new_graph_height):
+ self._graph_height = max(1, new_graph_height)
+
+ def resize_graph(self):
+ """
+ Prompts for user input to resize the graph panel. Options include...
+
+ * down arrow - grow graph
+ * up arrow - shrink graph
+ * enter / space - set size
+ """
+
+ control = nyx.controller.get_controller()
+
+ with panel.CURSES_LOCK:
+ try:
+ while True:
+ msg = 'press the down/up to resize the graph, and enter when done'
+ control.set_msg(msg, curses.A_BOLD, True)
+ curses.cbreak()
+ key = control.key_input()
+
+ if key.match('down'):
+ # don't grow the graph if it's already consuming the whole display
+ # (plus an extra line for the graph/log gap)
+
+ max_height = self.parent.getmaxyx()[0] - self.top
+ current_height = self.get_height()
+
+ if current_height < max_height + 1:
+ self.set_graph_height(self._graph_height + 1)
+ elif key.match('up'):
+ self.set_graph_height(self._graph_height - 1)
+ elif key.is_selection():
+ break
+
+ control.redraw()
+ finally:
+ control.set_msg()
+
+ def handle_key(self, key):
+ if key.match('r'):
+ self.resize_graph()
+ elif key.match('b'):
+ # uses the next boundary type
+ self.bounds_type = Bounds.next(self.bounds_type)
+ self.redraw(True)
+ elif key.match('s'):
+ # provides a menu to pick the graphed stats
+
+ available_stats = sorted(self.stat_options())
+ options = ['None'] + [stat.capitalize() for stat in available_stats]
+ initial_selection = available_stats.index(self.displayed_stat) + 1 if self.displayed_stat else 0
+
+ selection = nyx.popups.show_menu('Graphed Stats:', options, initial_selection)
+
+ # applies new setting
+
+ if selection == 0:
+ self.displayed_stat = None
+ elif selection != -1:
+ self.displayed_stat = available_stats[selection - 1]
+ elif key.match('i'):
+ # provides menu to pick graph panel update interval
+
+ selection = nyx.popups.show_menu('Update Interval:', list(Interval), list(Interval).index(self.update_interval))
+
+ if selection != -1:
+ self.update_interval = list(Interval)[selection]
+ else:
+ return False
+
+ return True
+
+ def get_help(self):
+ return [
+ ('r', 'resize graph', None),
+ ('s', 'graphed stats', self.displayed_stat if self.displayed_stat else 'none'),
+ ('b', 'graph bounds', self.bounds_type.replace('_', ' ')),
+ ('i', 'graph update interval', self.update_interval),
+ ]
+
+ def draw(self, width, height):
+ if not self.displayed_stat:
+ return
+
+ stat = self.get_attr('_stats')[self.displayed_stat]
+
+ attr = DrawAttributes(
+ stat = type(stat)(stat), # clone the GraphCategory
+ subgraph_height = self._graph_height + 2, # graph rows + header + x-axis label
+ subgraph_width = min(width / 2, CONFIG['features.graph.max_width']),
+ interval = self.update_interval,
+ bounds_type = self.bounds_type,
+ accounting = self.get_attr('_accounting_stats'),
+ )
+
+ if self.is_title_visible():
+ self.addstr(0, 0, attr.stat.title(width), curses.A_STANDOUT)
+
+ self._draw_subgraph(attr, attr.stat.primary, 0, PRIMARY_COLOR)
+ self._draw_subgraph(attr, attr.stat.secondary, attr.subgraph_width, SECONDARY_COLOR)
+
+ if attr.stat.stat_type() == GraphStat.BANDWIDTH:
+ if width <= COLLAPSE_WIDTH:
+ self._draw_bandwidth_stats(attr, width)
+
+ if attr.accounting:
+ self._draw_accounting_stats(attr)
+
+ def _draw_subgraph(self, attr, data, x, color):
+ # Concering our subgraph colums, the y-axis label can be at most six
+ # characters, with two spaces of padding on either side of the graph.
+ # Starting with the smallest size, then possibly raise it after determing
+ # the y_axis_labels.
+
+ subgraph_columns = attr.subgraph_width - 8
+ min_bound, max_bound = self._get_graph_bounds(attr, data, subgraph_columns)
+
+ x_axis_labels = self._get_x_axis_labels(attr, subgraph_columns)
+ y_axis_labels = self._get_y_axis_labels(attr, data, min_bound, max_bound)
+ subgraph_columns = max(subgraph_columns, attr.subgraph_width - max([len(label) for label in y_axis_labels.values()]) - 2)
+ axis_offset = max([len(label) for label in y_axis_labels.values()])
+
+ self.addstr(1, x, data.header(attr.subgraph_width), curses.A_BOLD, color)
+
+ for x_offset, label in x_axis_labels.items():
+ self.addstr(attr.subgraph_height, x + x_offset + axis_offset, label, color)
+
+ for y, label in y_axis_labels.items():
+ self.addstr(y, x, label, color)
+
+ for col in range(subgraph_columns):
+ column_count = int(data.values[attr.interval][col]) - min_bound
+ column_height = int(min(attr.subgraph_height - 2, (attr.subgraph_height - 2) * column_count / (max(1, max_bound) - min_bound)))
+
+ for row in range(column_height):
+ self.addstr(attr.subgraph_height - 1 - row, x + col + axis_offset + 1, ' ', curses.A_STANDOUT, color)
+
+ def _get_graph_bounds(self, attr, data, subgraph_columns):
+ """
+ Provides the range the graph shows (ie, its minimum and maximum value).
+ """
+
+ min_bound, max_bound = 0, 0
+ values = data.values[attr.interval][:subgraph_columns]
+
+ if attr.bounds_type == Bounds.GLOBAL_MAX:
+ max_bound = data.max_value[attr.interval]
+ elif subgraph_columns > 0:
+ max_bound = max(values) # local maxima
+
+ if attr.bounds_type == Bounds.TIGHT and subgraph_columns > 0:
+ min_bound = min(values)
+
+ # if the max = min pick zero so we still display something
+
+ if min_bound == max_bound:
+ min_bound = 0
+
+ return min_bound, max_bound
+
+ def _get_y_axis_labels(self, attr, data, min_bound, max_bound):
+ """
+ Provides the labels for the y-axis. This is a mapping of the position it
+ should be drawn at to its text.
+ """
+
+ y_axis_labels = {
+ 2: data.y_axis_label(max_bound),
+ attr.subgraph_height - 1: data.y_axis_label(min_bound),
+ }
+
+ ticks = (attr.subgraph_height - 5) / 2
+
+ for i in range(ticks):
+ row = attr.subgraph_height - (2 * i) - 5
+
+ if attr.subgraph_height % 2 == 0 and i >= (ticks / 2):
+ row -= 1 # make extra gap be in the middle when we're an even size
+
+ val = (max_bound - min_bound) * (attr.subgraph_height - row - 3) / (attr.subgraph_height - 3)
+
+ if val not in (min_bound, max_bound):
+ y_axis_labels[row + 2] = data.y_axis_label(val)
+
+ return y_axis_labels
+
+ def _get_x_axis_labels(self, attr, subgraph_columns):
+ """
+ Provides the labels for the x-axis. We include the units for only its first
+ value, then bump the precision for subsequent units. For example...
+
+ 10s, 20, 30, 40, 50, 1m, 1.1, 1.3, 1.5
+ """
+
+ x_axis_labels = {}
+
+ interval_sec = INTERVAL_SECONDS[attr.interval]
+ interval_spacing = 10 if subgraph_columns >= WIDE_LABELING_GRAPH_COL else 5
+ units_label, decimal_precision = None, 0
+
+ for i in range((subgraph_columns - 4) / interval_spacing):
+ x = (i + 1) * interval_spacing
+ time_label = str_tools.time_label(x * interval_sec, decimal_precision)
+
+ if not units_label:
+ units_label = time_label[-1]
+ elif units_label != time_label[-1]:
+ # upped scale so also up precision of future measurements
+ units_label = time_label[-1]
+ decimal_precision += 1
+ else:
+ # if constrained on space then strips labeling since already provided
+ time_label = time_label[:-1]
+
+ x_axis_labels[x] = time_label
+
+ return x_axis_labels
+
+ def _draw_bandwidth_stats(self, attr, width):
+ """
+ Replaces the x-axis labeling with bandwidth stats. This is done on small
+ screens since this information otherwise wouldn't fit.
+ """
+
+ labeling_line = DEFAULT_CONTENT_HEIGHT + attr.subgraph_height - 4
+ self.addstr(labeling_line, 0, ' ' * width) # clear line
+
+ runtime = time.time() - attr.stat.start_time
+ primary_footer = 'total: %s, avg: %s/sec' % (_size_label(attr.stat.primary.total), _size_label(attr.stat.primary.total / runtime))
+ secondary_footer = 'total: %s, avg: %s/sec' % (_size_label(attr.stat.secondary.total), _size_label(attr.stat.secondary.total / runtime))
+
+ self.addstr(labeling_line, 1, primary_footer, PRIMARY_COLOR)
+ self.addstr(labeling_line, attr.subgraph_width + 1, secondary_footer, SECONDARY_COLOR)
+
+ def _draw_accounting_stats(self, attr):
+ y = DEFAULT_CONTENT_HEIGHT + attr.subgraph_height - 2
+
+ if tor_controller().is_alive():
+ hibernate_color = CONFIG['attr.hibernate_color'].get(attr.accounting.status, 'red')
+
+ x = self.addstr(y, 0, 'Accounting (', curses.A_BOLD)
+ x = self.addstr(y, x, attr.accounting.status, curses.A_BOLD, hibernate_color)
+ x = self.addstr(y, x, ')', curses.A_BOLD)
+
+ self.addstr(y, 35, 'Time to reset: %s' % str_tools.short_time_label(attr.accounting.time_until_reset))
+
+ self.addstr(y + 1, 2, '%s / %s' % (attr.accounting.read_bytes, attr.accounting.read_limit), PRIMARY_COLOR)
+ self.addstr(y + 1, 37, '%s / %s' % (attr.accounting.written_bytes, attr.accounting.write_limit), SECONDARY_COLOR)
+ else:
+ self.addstr(y, 0, 'Accounting:', curses.A_BOLD)
+ self.addstr(y, 12, 'Connection Closed...')
+
+ def copy_attr(self, attr):
+ if attr == '_stats':
+ return dict([(key, type(self._stats[key])(self._stats[key])) for key in self._stats])
+ else:
+ return panel.Panel.copy_attr(self, attr)
+
+ def _update_accounting(self, event):
+ if not CONFIG['features.graph.bw.accounting.show']:
+ self._accounting_stats = None
+ elif not self._accounting_stats or time.time() - self._accounting_stats.retrieved >= ACCOUNTING_RATE:
+ old_accounting_stats = self._accounting_stats
+ self._accounting_stats = tor_controller().get_accounting_stats(None)
+
+ # if we either added or removed accounting info then redraw the whole
+ # screen to account for resizing
+
+ if bool(old_accounting_stats) != bool(self._accounting_stats):
+ nyx.controller.get_controller().redraw()
+
+ def _update_stats(self, event):
+ for stat in self._stats.values():
+ stat.bandwidth_event(event)
+
+ if self.displayed_stat:
+ param = self.get_attr('_stats')[self.displayed_stat]
+ update_rate = INTERVAL_SECONDS[self.update_interval]
+
+ if param.primary.tick % update_rate == 0:
+ self.redraw(True)
+
+
+def _size_label(byte_count, decimal = 1):
+ """
+ Alias for str_tools.size_label() that accounts for if the user prefers bits
+ or bytes.
+ """
+
+ return str_tools.size_label(byte_count, decimal, is_bytes = CONFIG['features.graph.bw.transferInBytes'])
diff --git a/nyx/panel/header.py b/nyx/panel/header.py
new file mode 100644
index 0000000..0d6591a
--- /dev/null
+++ b/nyx/panel/header.py
@@ -0,0 +1,496 @@
+"""
+Top panel for every page, containing basic system and tor related information.
+This expands the information it presents to two columns if there's room
+available.
+"""
+
+import collections
+import os
+import time
+import curses
+import threading
+
+import stem
+
+import nyx.controller
+import nyx.popups
+
+from stem.control import Listener, State
+from stem.util import conf, log, proc, str_tools, system
+from nyx.util import msg, tor_controller, panel, tracker
+
+MIN_DUAL_COL_WIDTH = 141 # minimum width where we'll show two columns
+SHOW_FD_THRESHOLD = 60 # show file descriptor usage if usage is over this percentage
+UPDATE_RATE = 5 # rate in seconds at which we refresh
+
+CONFIG = conf.config_dict('nyx', {
+ 'attr.flag_colors': {},
+ 'attr.version_status_colors': {},
+})
+
+
+class HeaderPanel(panel.Panel, threading.Thread):
+ """
+ Top area containing tor settings and system information.
+ """
+
+ def __init__(self, stdscr):
+ panel.Panel.__init__(self, stdscr, 'header', 0)
+ threading.Thread.__init__(self)
+ self.setDaemon(True)
+
+ self._vals = get_sampling()
+
+ self._pause_condition = threading.Condition()
+ self._halt = False # terminates thread if true
+ self._reported_inactive = False
+
+ tor_controller().add_status_listener(self.reset_listener)
+
+ def is_wide(self, width = None):
+ """
+ True if we should show two columns of information, False otherwise.
+ """
+
+ if width is None:
+ width = self.get_parent().getmaxyx()[1]
+
+ return width >= MIN_DUAL_COL_WIDTH
+
+ def get_height(self):
+ """
+ Provides the height of the content, which is dynamically determined by the
+ panel's maximum width.
+ """
+
+ if self._vals.is_relay:
+ return 4 if self.is_wide() else 6
+ else:
+ return 3 if self.is_wide() else 4
+
+ def send_newnym(self):
+ """
+ Requests a new identity and provides a visual queue.
+ """
+
+ controller = tor_controller()
+
+ if not controller.is_newnym_available():
+ return
+
+ controller.signal(stem.Signal.NEWNYM)
+
+ # If we're wide then the newnym label in this panel will give an
+ # indication that the signal was sent. Otherwise use a msg.
+
+ if not self.is_wide():
+ nyx.popups.show_msg('Requesting a new identity', 1)
+
+ def handle_key(self, key):
+ if key.match('n'):
+ self.send_newnym()
+ elif key.match('r') and not self._vals.is_connected:
+ # TODO: This is borked. Not quite sure why but our attempt to call
+ # PROTOCOLINFO fails with a socket error, followed by completely freezing
+ # nyx. This is exposing two bugs...
+ #
+ # * This should be working. That's a stem issue.
+ # * Our interface shouldn't be locking up. That's an nyx issue.
+
+ return True
+
+ controller = tor_controller()
+
+ try:
+ controller.connect()
+
+ try:
+ controller.authenticate() # TODO: should account for our chroot
+ except stem.connection.MissingPassword:
+ password = nyx.popups.input_prompt('Controller Password: ')
+
+ if password:
+ controller.authenticate(password)
+
+ log.notice("Reconnected to Tor's control port")
+ nyx.popups.show_msg('Tor reconnected', 1)
+ except Exception as exc:
+ nyx.popups.show_msg('Unable to reconnect (%s)' % exc, 3)
+ controller.close()
+ else:
+ return False
+
+ return True
+
+ def draw(self, width, height):
+ vals = self._vals # local reference to avoid concurrency concerns
+ is_wide = self.is_wide(width)
+
+ # space available for content
+
+ left_width = max(width / 2, 77) if is_wide else width
+ right_width = width - left_width
+
+ self._draw_platform_section(0, 0, left_width, vals)
+
+ if vals.is_connected:
+ self._draw_ports_section(0, 1, left_width, vals)
+ else:
+ self._draw_disconnected(0, 1, left_width, vals)
+
+ if is_wide:
+ self._draw_resource_usage(left_width, 0, right_width, vals)
+
+ if vals.is_relay:
+ self._draw_fingerprint_and_fd_usage(left_width, 1, right_width, vals)
+ self._draw_flags(0, 2, left_width, vals)
+ self._draw_exit_policy(left_width, 2, right_width, vals)
+ elif vals.is_connected:
+ self._draw_newnym_option(left_width, 1, right_width, vals)
+ else:
+ self._draw_resource_usage(0, 2, left_width, vals)
+
+ if vals.is_relay:
+ self._draw_fingerprint_and_fd_usage(0, 3, left_width, vals)
+ self._draw_flags(0, 4, left_width, vals)
+
+ def _draw_platform_section(self, x, y, width, vals):
+ """
+ Section providing the user's hostname, platform, and version information...
+
+ nyx - odin (Linux 3.5.0-52-generic) Tor 0.2.5.1-alpha-dev (unrecommended)
+ |------ platform (40 characters) ------| |----------- tor version -----------|
+ """
+
+ initial_x, space_left = x, min(width, 40)
+
+ x = self.addstr(y, x, vals.format('nyx - {hostname}', space_left))
+ space_left -= x - initial_x
+
+ if space_left >= 10:
+ self.addstr(y, x, ' (%s)' % vals.format('{platform}', space_left - 3))
+
+ x, space_left = initial_x + 43, width - 43
+
+ if vals.version != 'Unknown' and space_left >= 10:
+ x = self.addstr(y, x, vals.format('Tor {version}', space_left))
+ space_left -= x - 43 - initial_x
+
+ if space_left >= 7 + len(vals.version_status):
+ version_color = CONFIG['attr.version_status_colors'].get(vals.version_status, 'white')
+
+ x = self.addstr(y, x, ' (')
+ x = self.addstr(y, x, vals.version_status, version_color)
+ self.addstr(y, x, ')')
+
+ def _draw_ports_section(self, x, y, width, vals):
+ """
+ Section providing our nickname, address, and port information...
+
+ Unnamed - 0.0.0.0:7000, Control Port (cookie): 9051
+ """
+
+ if not vals.is_relay:
+ x = self.addstr(y, x, 'Relaying Disabled', 'cyan')
+ else:
+ x = self.addstr(y, x, vals.format('{nickname} - {address}:{or_port}'))
+
+ if vals.dir_port != '0':
+ x = self.addstr(y, x, vals.format(', Dir Port: {dir_port}'))
+
+ if vals.control_port:
+ if width >= x + 19 + len(vals.control_port) + len(vals.auth_type):
+ auth_color = 'red' if vals.auth_type == 'open' else 'green'
+
+ x = self.addstr(y, x, ', Control Port (')
+ x = self.addstr(y, x, vals.auth_type, auth_color)
+ self.addstr(y, x, vals.format('): {control_port}'))
+ else:
+ self.addstr(y, x, vals.format(', Control Port: {control_port}'))
+ elif vals.socket_path:
+ self.addstr(y, x, vals.format(', Control Socket: {socket_path}'))
+
+ def _draw_disconnected(self, x, y, width, vals):
+ """
+ Message indicating that tor is disconnected...
+
+ Tor Disconnected (15:21 07/13/2014, press r to reconnect)
+ """
+
+ x = self.addstr(y, x, 'Tor Disconnected', curses.A_BOLD, 'red')
+ last_heartbeat = time.strftime('%H:%M %m/%d/%Y', time.localtime(vals.last_heartbeat))
+ self.addstr(y, x, ' (%s, press r to reconnect)' % last_heartbeat)
+
+ def _draw_resource_usage(self, x, y, width, vals):
+ """
+ System resource usage of the tor process...
+
+ cpu: 0.0% tor, 1.0% nyx mem: 0 (0.0%) pid: 16329 uptime: 12-20:42:07
+ """
+
+ if vals.start_time:
+ if not vals.is_connected:
+ now = vals.connection_time
+ elif self.is_paused():
+ now = self.get_pause_time()
+ else:
+ now = time.time()
+
+ uptime = str_tools.short_time_label(now - vals.start_time)
+ else:
+ uptime = ''
+
+ sys_fields = (
+ (0, vals.format('cpu: {tor_cpu}% tor, {nyx_cpu}% nyx')),
+ (27, vals.format('mem: {memory} ({memory_percent}%)')),
+ (47, vals.format('pid: {pid}')),
+ (59, 'uptime: %s' % uptime),
+ )
+
+ for (start, label) in sys_fields:
+ if width >= start + len(label):
+ self.addstr(y, x + start, label)
+ else:
+ break
+
+ def _draw_fingerprint_and_fd_usage(self, x, y, width, vals):
+ """
+ Presents our fingerprint, and our file descriptor usage if we're running
+ out...
+
+ fingerprint: 1A94D1A794FCB2F8B6CBC179EF8FDD4008A98D3B, file desc: 900 / 1000 (90%)
+ """
+
+ initial_x, space_left = x, width
+
+ x = self.addstr(y, x, vals.format('fingerprint: {fingerprint}', width))
+ space_left -= x - initial_x
+
+ if space_left >= 30 and vals.fd_used and vals.fd_limit != -1:
+ fd_percent = 100 * vals.fd_used / vals.fd_limit
+
+ if fd_percent >= SHOW_FD_THRESHOLD:
+ if fd_percent >= 95:
+ percentage_format = (curses.A_BOLD, 'red')
+ elif fd_percent >= 90:
+ percentage_format = ('red',)
+ elif fd_percent >= 60:
+ percentage_format = ('yellow',)
+ else:
+ percentage_format = ()
+
+ x = self.addstr(y, x, ', file descriptors' if space_left >= 37 else ', file desc')
+ x = self.addstr(y, x, vals.format(': {fd_used} / {fd_limit} ('))
+ x = self.addstr(y, x, '%i%%' % fd_percent, *percentage_format)
+ self.addstr(y, x, ')')
+
+ def _draw_flags(self, x, y, width, vals):
+ """
+ Presents flags held by our relay...
+
+ flags: Running, Valid
+ """
+
+ x = self.addstr(y, x, 'flags: ')
+
+ if vals.flags:
+ for i, flag in enumerate(vals.flags):
+ flag_color = CONFIG['attr.flag_colors'].get(flag, 'white')
+ x = self.addstr(y, x, flag, curses.A_BOLD, flag_color)
+
+ if i < len(vals.flags) - 1:
+ x = self.addstr(y, x, ', ')
+ else:
+ self.addstr(y, x, 'none', curses.A_BOLD, 'cyan')
+
+ def _draw_exit_policy(self, x, y, width, vals):
+ """
+ Presents our exit policy...
+
+ exit policy: reject *:*
+ """
+
+ x = self.addstr(y, x, 'exit policy: ')
+
+ if not vals.exit_policy:
+ return
+
+ rules = list(vals.exit_policy.strip_private().strip_default())
+
+ for i, rule in enumerate(rules):
+ policy_color = 'green' if rule.is_accept else 'red'
+ x = self.addstr(y, x, str(rule), curses.A_BOLD, policy_color)
+
+ if i < len(rules) - 1:
+ x = self.addstr(y, x, ', ')
+
+ if vals.exit_policy.has_default():
+ if rules:
+ x = self.addstr(y, x, ', ')
+
+ self.addstr(y, x, '<default>', curses.A_BOLD, 'cyan')
+
+ def _draw_newnym_option(self, x, y, width, vals):
+ """
+ Provide a notice for requiesting a new identity, and time until it's next
+ available if in the process of building circuits.
+ """
+
+ if vals.newnym_wait == 0:
+ self.addstr(y, x, "press 'n' for a new identity")
+ else:
+ plural = 's' if vals.newnym_wait > 1 else ''
+ self.addstr(y, x, 'building circuits, available again in %i second%s' % (vals.newnym_wait, plural))
+
+ def run(self):
+ """
+ Keeps stats updated, checking for new information at a set rate.
+ """
+
+ last_ran = -1
+
+ while not self._halt:
+ if self.is_paused() or not self._vals.is_connected or (time.time() - last_ran) < UPDATE_RATE:
+ with self._pause_condition:
+ if not self._halt:
+ self._pause_condition.wait(0.2)
+
+ continue # done waiting, try again
+
+ self._update()
+ last_ran = time.time()
+
+ def stop(self):
+ """
+ Halts further resolutions and terminates the thread.
+ """
+
+ with self._pause_condition:
+ self._halt = True
+ self._pause_condition.notifyAll()
+
+ def reset_listener(self, controller, event_type, _):
+ self._update()
+
+ if event_type == State.CLOSED:
+ log.notice('Tor control port closed')
+
+ def _update(self):
+ previous_height = self.get_height()
+ self._vals = get_sampling(self._vals)
+
+ if self._vals.fd_used and self._vals.fd_limit != -1:
+ fd_percent = 100 * self._vals.fd_used / self._vals.fd_limit
+
+ if fd_percent >= 90:
+ log_msg = msg('panel.header.fd_used_at_ninety_percent', percentage = fd_percent)
+ log.log_once('fd_used_at_ninety_percent', log.WARN, log_msg)
+ log.DEDUPLICATION_MESSAGE_IDS.add('fd_used_at_sixty_percent')
+ elif fd_percent >= 60:
+ log_msg = msg('panel.header.fd_used_at_sixty_percent', percentage = fd_percent)
+ log.log_once('fd_used_at_sixty_percent', log.NOTICE, log_msg)
+
+ if self._vals.is_connected:
+ if not self._reported_inactive and (time.time() - self._vals.last_heartbeat) >= 10:
+ self._reported_inactive = True
+ log.notice('Relay unresponsive (last heartbeat: %s)' % time.ctime(self._vals.last_heartbeat))
+ elif self._reported_inactive and (time.time() - self._vals.last_heartbeat) < 10:
+ self._reported_inactive = False
+ log.notice('Relay resumed')
+
+ if previous_height != self.get_height():
+ # We're toggling between being a relay and client, causing the height
+ # of this panel to change. Redraw all content so we don't get
+ # overlapping content.
+
+ nyx.controller.get_controller().redraw()
+ else:
+ self.redraw(True) # just need to redraw ourselves
+
+
+def get_sampling(last_sampling = None):
+ controller = tor_controller()
+ retrieved = time.time()
+
+ pid = controller.get_pid('')
+ tor_resources = tracker.get_resource_tracker().get_value()
+ nyx_total_cpu_time = sum(os.times()[:3])
+
+ or_listeners = controller.get_listeners(Listener.OR, [])
+ control_listeners = controller.get_listeners(Listener.CONTROL, [])
+
+ if controller.get_conf('HashedControlPassword', None):
+ auth_type = 'password'
+ elif controller.get_conf('CookieAuthentication', None) == '1':
+ auth_type = 'cookie'
+ else:
+ auth_type = 'open'
+
+ try:
+ fd_used = proc.file_descriptors_used(pid)
+ except IOError:
+ fd_used = None
+
+ if last_sampling:
+ nyx_cpu_delta = nyx_total_cpu_time - last_sampling.nyx_total_cpu_time
+ nyx_time_delta = retrieved - last_sampling.retrieved
+
+ python_cpu_time = nyx_cpu_delta / nyx_time_delta
+ sys_call_cpu_time = 0.0 # TODO: add a wrapper around call() to get this
+
+ nyx_cpu = python_cpu_time + sys_call_cpu_time
+ else:
+ nyx_cpu = 0.0
+
+ attr = {
+ 'retrieved': retrieved,
+ 'is_connected': controller.is_alive(),
+ 'connection_time': controller.connection_time(),
+ 'last_heartbeat': controller.get_latest_heartbeat(),
+
+ 'fingerprint': controller.get_info('fingerprint', 'Unknown'),
+ 'nickname': controller.get_conf('Nickname', ''),
+ 'newnym_wait': controller.get_newnym_wait(),
+ 'exit_policy': controller.get_exit_policy(None),
+ 'flags': getattr(controller.get_network_status(default = None), 'flags', []),
+
+ 'version': str(controller.get_version('Unknown')).split()[0],
+ 'version_status': controller.get_info('status/version/current', 'Unknown'),
+
+ 'address': or_listeners[0][0] if (or_listeners and or_listeners[0][0] != '0.0.0.0') else controller.get_info('address', 'Unknown'),
+ 'or_port': or_listeners[0][1] if or_listeners else '',
+ 'dir_port': controller.get_conf('DirPort', '0'),
+ 'control_port': str(control_listeners[0][1]) if control_listeners else None,
+ 'socket_path': controller.get_conf('ControlSocket', None),
+ 'is_relay': bool(or_listeners),
+
+ 'auth_type': auth_type,
+ 'pid': pid,
+ 'start_time': system.start_time(pid),
+ 'fd_limit': int(controller.get_info('process/descriptor-limit', '-1')),
+ 'fd_used': fd_used,
+
+ 'nyx_total_cpu_time': nyx_total_cpu_time,
+ 'tor_cpu': '%0.1f' % (100 * tor_resources.cpu_sample),
+ 'nyx_cpu': nyx_cpu,
+ 'memory': str_tools.size_label(tor_resources.memory_bytes) if tor_resources.memory_bytes > 0 else 0,
+ 'memory_percent': '%0.1f' % (100 * tor_resources.memory_percent),
+
+ 'hostname': os.uname()[1],
+ 'platform': '%s %s' % (os.uname()[0], os.uname()[2]), # [platform name] [version]
+ }
+
+ class Sampling(collections.namedtuple('Sampling', attr.keys())):
+ def __init__(self, **attr):
+ super(Sampling, self).__init__(**attr)
+ self._attr = attr
+
+ def format(self, message, crop_width = None):
+ formatted_msg = message.format(**self._attr)
+
+ if crop_width:
+ formatted_msg = str_tools.crop(formatted_msg, crop_width)
+
+ return formatted_msg
+
+ return Sampling(**attr)
diff --git a/nyx/panel/log.py b/nyx/panel/log.py
new file mode 100644
index 0000000..708a679
--- /dev/null
+++ b/nyx/panel/log.py
@@ -0,0 +1,454 @@
+"""
+Panel providing a chronological log of events its been configured to listen
+for. This provides prepopulation from the log file and supports filtering by
+regular expressions.
+"""
+
+import os
+import time
+import curses
+import threading
+
+import stem.response.events
+
+import nyx.arguments
+import nyx.popups
+import nyx.util.log
+
+from nyx.util import join, panel, tor_controller, ui_tools
+from stem.util import conf, log
+
+
+def conf_handler(key, value):
+ if key == 'features.log.prepopulateReadLimit':
+ return max(0, value)
+ elif key == 'features.log.maxRefreshRate':
+ return max(10, value)
+ elif key == 'cache.log_panel.size':
+ return max(1000, value)
+
+
+CONFIG = conf.config_dict('nyx', {
+ 'attr.log_color': {},
+ 'cache.log_panel.size': 1000,
+ 'features.logFile': '',
+ 'features.log.showDuplicateEntries': False,
+ 'features.log.prepopulate': True,
+ 'features.log.prepopulateReadLimit': 5000,
+ 'features.log.maxRefreshRate': 300,
+ 'features.log.regex': [],
+ 'msg.misc.event_types': '',
+ 'startup.events': 'N3',
+}, conf_handler)
+
+# The height of the drawn content is estimated based on the last time we redrew
+# the panel. It's chiefly used for scrolling and the bar indicating its
+# position. Letting the estimate be too inaccurate results in a display bug, so
+# redraws the display if it's off by this threshold.
+
+CONTENT_HEIGHT_REDRAW_THRESHOLD = 3
+
+# Log buffer so we start collecting stem/nyx events when imported. This is used
+# to make our LogPanel when curses initializes.
+
+stem_logger = log.get_logger()
+NYX_LOGGER = log.LogBuffer(log.Runlevel.DEBUG, yield_records = True)
+stem_logger.addHandler(NYX_LOGGER)
+
+
+class LogPanel(panel.Panel, threading.Thread):
+ """
+ Listens for and displays tor, nyx, and stem events. This prepopulates
+ from tor's log file if it exists.
+ """
+
+ def __init__(self, stdscr):
+ panel.Panel.__init__(self, stdscr, 'log', 0)
+ threading.Thread.__init__(self)
+ self.setDaemon(True)
+
+ logged_events = nyx.arguments.expand_events(CONFIG['startup.events'])
+ self._event_log = nyx.util.log.LogGroup(CONFIG['cache.log_panel.size'], group_by_day = True)
+ self._event_types = nyx.util.log.listen_for_events(self._register_tor_event, logged_events)
+ self._log_file = nyx.util.log.LogFileOutput(CONFIG['features.logFile'])
+ self._filter = nyx.util.log.LogFilters(initial_filters = CONFIG['features.log.regex'])
+ self._show_duplicates = CONFIG['features.log.showDuplicateEntries']
+
+ self.set_pause_attr('_event_log')
+
+ self._halt = False # terminates thread if true
+ self._pause_condition = threading.Condition()
+ self._has_new_event = False
+
+ # fetches past tor events from log file, if available
+
+ if CONFIG['features.log.prepopulate']:
+ log_location = nyx.util.log.log_file_path(tor_controller())
+
+ if log_location:
+ try:
+ for entry in reversed(list(nyx.util.log.read_tor_log(log_location, CONFIG['features.log.prepopulateReadLimit']))):
+ if entry.type in self._event_types:
+ self._event_log.add(entry)
+ except IOError as exc:
+ log.info('Unable to read log located at %s: %s' % (log_location, exc))
+ except ValueError as exc:
+ log.info(str(exc))
+
+ self._last_content_height = len(self._event_log) # height of the rendered content when last drawn
+ self._scroll = 0
+
+ # merge NYX_LOGGER into us, and listen for its future events
+
+ for event in NYX_LOGGER:
+ self._register_nyx_event(event)
+
+ NYX_LOGGER.emit = self._register_nyx_event
+
+ def set_duplicate_visability(self, is_visible):
+ """
+ Sets if duplicate log entries are collaped or expanded.
+
+ :param bool is_visible: if **True** all log entries are shown, otherwise
+ they're deduplicated
+ """
+
+ self._show_duplicates = is_visible
+
+ def get_filter(self):
+ """
+ Provides our currently selected regex filter.
+ """
+
+ return self._filter
+
+ def show_filter_prompt(self):
+ """
+ Prompts the user to add a new regex filter.
+ """
+
+ regex_input = nyx.popups.input_prompt('Regular expression: ')
+
+ if regex_input:
+ self._filter.select(regex_input)
+
+ def show_event_selection_prompt(self):
+ """
+ Prompts the user to select the events being listened for.
+ """
+
+ # allow user to enter new types of events to log - unchanged if left blank
+
+ with nyx.popups.popup_window(16, 80) as (popup, width, height):
+ if popup:
+ # displays the available flags
+
+ popup.win.box()
+ popup.addstr(0, 0, 'Event Types:', curses.A_STANDOUT)
+ event_lines = CONFIG['msg.misc.event_types'].split('\n')
+
+ for i in range(len(event_lines)):
+ popup.addstr(i + 1, 1, event_lines[i][6:])
+
+ popup.win.refresh()
+
+ user_input = nyx.popups.input_prompt('Events to log: ')
+
+ if user_input:
+ try:
+ user_input = user_input.replace(' ', '') # strip spaces
+ event_types = nyx.arguments.expand_events(user_input)
+
+ if event_types != self._event_types:
+ self._event_types = nyx.util.log.listen_for_events(self._register_tor_event, event_types)
+ self.redraw(True)
+ except ValueError as exc:
+ nyx.popups.show_msg('Invalid flags: %s' % str(exc), 2)
+
+ def show_snapshot_prompt(self):
+ """
+ Lets user enter a path to take a snapshot, canceling if left blank.
+ """
+
+ path_input = nyx.popups.input_prompt('Path to save log snapshot: ')
+
+ if path_input:
+ try:
+ self.save_snapshot(path_input)
+ nyx.popups.show_msg('Saved: %s' % path_input, 2)
+ except IOError as exc:
+ nyx.popups.show_msg('Unable to save snapshot: %s' % exc, 2)
+
+ def clear(self):
+ """
+ Clears the contents of the event log.
+ """
+
+ self._event_log = nyx.util.log.LogGroup(CONFIG['cache.log_panel.size'], group_by_day = True)
+ self.redraw(True)
+
+ def save_snapshot(self, path):
+ """
+ Saves the log events currently being displayed to the given path. This
+ takes filers into account. This overwrites the file if it already exists.
+
+ :param str path: path where to save the log snapshot
+
+ :raises: **IOError** if unsuccessful
+ """
+
+ path = os.path.abspath(os.path.expanduser(path))
+
+ # make dir if the path doesn't already exist
+
+ base_dir = os.path.dirname(path)
+
+ try:
+ if not os.path.exists(base_dir):
+ os.makedirs(base_dir)
+ except OSError as exc:
+ raise IOError("unable to make directory '%s'" % base_dir)
+
+ event_log = list(self._event_log)
+ event_filter = self._filter.clone()
+
+ with open(path, 'w') as snapshot_file:
+ try:
+ for entry in reversed(event_log):
+ if event_filter.match(entry.display_message):
+ snapshot_file.write(entry.display_message + '\n')
+ except Exception as exc:
+ raise IOError("unable to write to '%s': %s" % (path, exc))
+
+ def handle_key(self, key):
+ if key.is_scroll():
+ page_height = self.get_preferred_size()[0] - 1
+ new_scroll = ui_tools.get_scroll_position(key, self._scroll, page_height, self._last_content_height)
+
+ if self._scroll != new_scroll:
+ self._scroll = new_scroll
+ self.redraw(True)
+ elif key.match('u'):
+ self.set_duplicate_visability(not self._show_duplicates)
+ self.redraw(True)
+ elif key.match('c'):
+ msg = 'This will clear the log. Are you sure (c again to confirm)?'
+ key_press = nyx.popups.show_msg(msg, attr = curses.A_BOLD)
+
+ if key_press.match('c'):
+ self.clear()
+ elif key.match('f'):
+ with panel.CURSES_LOCK:
+ initial_selection = 1 if self._filter.selection() else 0
+ options = ['None'] + self._filter.latest_selections() + ['New...']
+ selection = nyx.popups.show_menu('Log Filter:', options, initial_selection)
+
+ if selection == 0:
+ self._filter.select(None)
+ elif selection == len(options) - 1:
+ # selected 'New...' option - prompt user to input regular expression
+ self.show_filter_prompt()
+ elif selection != -1:
+ self._filter.select(self._filter.latest_selections()[selection - 1])
+ elif key.match('e'):
+ self.show_event_selection_prompt()
+ elif key.match('a'):
+ self.show_snapshot_prompt()
+ else:
+ return False
+
+ return True
+
+ def get_help(self):
+ return [
+ ('up arrow', 'scroll log up a line', None),
+ ('down arrow', 'scroll log down a line', None),
+ ('a', 'save snapshot of the log', None),
+ ('e', 'change logged events', None),
+ ('f', 'log regex filter', 'enabled' if self._filter.selection() else 'disabled'),
+ ('u', 'duplicate log entries', 'visible' if self._show_duplicates else 'hidden'),
+ ('c', 'clear event log', None),
+ ]
+
+ def draw(self, width, height):
+ self._scroll = max(0, min(self._scroll, self._last_content_height - height + 1))
+
+ event_log = list(self.get_attr('_event_log'))
+ event_filter = self._filter.clone()
+ event_types = list(self._event_types)
+ scroll = int(self._scroll)
+ last_content_height = self._last_content_height
+ show_duplicates = self._show_duplicates
+
+ is_scrollbar_visible = last_content_height > height - 1
+
+ if is_scrollbar_visible:
+ self.add_scroll_bar(scroll, scroll + height - 1, last_content_height, 1)
+
+ x, y = 3 if is_scrollbar_visible else 1, 1 - scroll
+
+ # group entries by date, filtering out those that aren't visible
+
+ day_to_entries, today = {}, nyx.util.log.day_count(time.time())
+
+ for entry in event_log:
+ if entry.is_duplicate and not show_duplicates:
+ continue # deduplicated message
+ elif not event_filter.match(entry.display_message):
+ continue # filter doesn't match log message
+
+ day_to_entries.setdefault(entry.day_count(), []).append(entry)
+
+ for day in sorted(day_to_entries.keys(), reverse = True):
+ if day == today:
+ for entry in day_to_entries[day]:
+ y = self._draw_entry(x, y, width, entry, show_duplicates)
+ else:
+ original_y, y = y, y + 1
+
+ for entry in day_to_entries[day]:
+ y = self._draw_entry(x, y, width, entry, show_duplicates)
+
+ ui_tools.draw_box(self, original_y, x - 1, width - x + 1, y - original_y + 1, curses.A_BOLD, 'yellow')
+ time_label = time.strftime(' %B %d, %Y ', time.localtime(day_to_entries[day][0].timestamp))
+ self.addstr(original_y, x + 1, time_label, curses.A_BOLD, curses.A_BOLD, 'yellow')
+
+ y += 1
+
+ # drawing the title after the content, so we'll clear content from the top line
+
+ if self.is_title_visible():
+ self._draw_title(width, event_types, event_filter)
+
+ # redraw the display if...
+ # - last_content_height was off by too much
+ # - we're off the bottom of the page
+
+ new_content_height = y + scroll - 1
+ content_height_delta = abs(last_content_height - new_content_height)
+ force_redraw, force_redraw_reason = True, ''
+
+ if content_height_delta >= CONTENT_HEIGHT_REDRAW_THRESHOLD:
+ force_redraw_reason = 'estimate was off by %i' % content_height_delta
+ elif new_content_height > height and self._scroll + height - 1 > new_content_height:
+ force_redraw_reason = 'scrolled off the bottom of the page'
+ elif not is_scrollbar_visible and new_content_height > height - 1:
+ force_redraw_reason = "scroll bar wasn't previously visible"
+ elif is_scrollbar_visible and new_content_height <= height - 1:
+ force_redraw_reason = "scroll bar shouldn't be visible"
+ else:
+ force_redraw = False
+
+ self._last_content_height = new_content_height
+ self._has_new_event = False
+
+ if force_redraw:
+ log.debug('redrawing the log panel with the corrected content height (%s)' % force_redraw_reason)
+ self.redraw(True)
+
+ def _draw_title(self, width, event_types, event_filter):
+ """
+ Panel title with the event types we're logging and our regex filter if set.
+ """
+
+ self.addstr(0, 0, ' ' * width) # clear line
+ title_comp = list(nyx.util.log.condense_runlevels(*event_types))
+
+ if event_filter.selection():
+ title_comp.append('filter: %s' % event_filter.selection())
+
+ title_comp_str = join(title_comp, ', ', width - 10)
+ title = 'Events (%s):' % title_comp_str if title_comp_str else 'Events:'
+
+ self.addstr(0, 0, title, curses.A_STANDOUT)
+
+ def _draw_entry(self, x, y, width, entry, show_duplicates):
+ """
+ Presents a log entry with line wrapping.
+ """
+
+ min_x, msg = x + 2, entry.display_message
+ boldness = curses.A_BOLD if 'ERR' in entry.type else curses.A_NORMAL # emphasize ERR messages
+ color = CONFIG['attr.log_color'].get(entry.type, 'white')
+
+ for line in msg.splitlines():
+ x, y = self.addstr_wrap(y, x, line, width, min_x, boldness, color)
+
+ if entry.duplicates and not show_duplicates:
+ duplicate_count = len(entry.duplicates) - 1
+ plural = 's' if duplicate_count > 1 else ''
+ duplicate_msg = ' [%i duplicate%s hidden]' % (duplicate_count, plural)
+ x, y = self.addstr_wrap(y, x, duplicate_msg, width, min_x, curses.A_BOLD, 'green')
+
+ return y + 1
+
+ def run(self):
+ """
+ Redraws the display, coalescing updates if events are rapidly logged (for
+ instance running at the DEBUG runlevel) while also being immediately
+ responsive if additions are less frequent.
+ """
+
+ last_ran, last_day = -1, nyx.util.log.day_count(time.time())
+
+ while not self._halt:
+ current_day = nyx.util.log.day_count(time.time())
+ time_since_reset = time.time() - last_ran
+ max_log_update_rate = CONFIG['features.log.maxRefreshRate'] / 1000.0
+
+ sleep_time = 0
+
+ if (not self._has_new_event and last_day == current_day) or self.is_paused():
+ sleep_time = 5
+ elif time_since_reset < max_log_update_rate:
+ sleep_time = max(0.05, max_log_update_rate - time_since_reset)
+
+ if sleep_time:
+ with self._pause_condition:
+ if not self._halt:
+ self._pause_condition.wait(sleep_time)
+
+ continue
+
+ last_ran, last_day = time.time(), current_day
+ self.redraw(True)
+
+ def stop(self):
+ """
+ Halts further updates and terminates the thread.
+ """
+
+ with self._pause_condition:
+ self._halt = True
+ self._pause_condition.notifyAll()
+
+ def _register_tor_event(self, event):
+ msg = ' '.join(str(event).split(' ')[1:])
+
+ if isinstance(event, stem.response.events.BandwidthEvent):
+ msg = 'READ: %i, WRITTEN: %i' % (event.read, event.written)
+ elif isinstance(event, stem.response.events.LogEvent):
+ msg = event.message
+
+ self._register_event(nyx.util.log.LogEntry(event.arrived_at, event.type, msg))
+
+ def _register_nyx_event(self, record):
+ if record.levelname == 'WARNING':
+ record.levelname = 'WARN'
+
+ self._register_event(nyx.util.log.LogEntry(int(record.created), 'NYX_%s' % record.levelname, record.msg))
+
+ def _register_event(self, event):
+ if event.type not in self._event_types:
+ return
+
+ self._event_log.add(event)
+ self._log_file.write(event.display_message)
+
+ # notifies the display that it has new content
+
+ if self._filter.match(event.display_message):
+ self._has_new_event = True
+
+ with self._pause_condition:
+ self._pause_condition.notifyAll()
diff --git a/nyx/panel/torrc.py b/nyx/panel/torrc.py
new file mode 100644
index 0000000..f0f66b4
--- /dev/null
+++ b/nyx/panel/torrc.py
@@ -0,0 +1,171 @@
+"""
+Panel displaying the torrc or nyxrc with the validation done against it.
+"""
+
+import math
+import curses
+
+from nyx.util import expand_path, msg, panel, tor_controller, ui_tools
+
+from stem import ControllerError
+from stem.control import State
+
+
+class TorrcPanel(panel.Panel):
+ """
+ Renders the current torrc or nyxrc with syntax highlighting in a scrollable
+ area.
+ """
+
+ def __init__(self, stdscr):
+ panel.Panel.__init__(self, stdscr, 'torrc', 0)
+
+ self._scroll = 0
+ self._show_line_numbers = True # shows left aligned line numbers
+ self._show_comments = True # shows comments and extra whitespace
+ self._last_content_height = 0
+
+ self._torrc_location = None
+ self._torrc_content = None
+ self._torrc_load_error = None
+
+ controller = tor_controller()
+ controller.add_status_listener(self.reset_listener)
+ self.reset_listener(controller, State.RESET, None)
+
+ def reset_listener(self, controller, event_type, _):
+ """
+ Reloads and displays the torrc on tor reload (sighup) events.
+ """
+
+ if event_type == State.RESET:
+ try:
+ self._torrc_location = expand_path(controller.get_info('config-file'))
+
+ with open(self._torrc_location) as torrc_file:
+ self._torrc_content = [ui_tools.get_printable(line.replace('\t', ' ')).rstrip() for line in torrc_file.readlines()]
+ except ControllerError as exc:
+ self._torrc_load_error = msg('panel.torrc.unable_to_find_torrc', error = exc)
+ self._torrc_location = None
+ self._torrc_content = None
+ except Exception as exc:
+ self._torrc_load_error = msg('panel.torrc.unable_to_load_torrc', error = exc.strerror)
+ self._torrc_content = None
+
+ def set_comments_visible(self, is_visible):
+ """
+ Sets if comments and blank lines are shown or stripped.
+
+ :var bool is_visible: shows comments if true, strips otherwise
+ """
+
+ self._show_comments = is_visible
+ self.redraw(True)
+
+ def set_line_number_visible(self, is_visible):
+ """
+ Sets if line numbers are shown or hidden.
+
+ :var bool is_visible: displays line numbers if true, hides otherwise
+ """
+
+ self._show_line_numbers = is_visible
+ self.redraw(True)
+
+ def handle_key(self, key):
+ if key.is_scroll():
+ page_height = self.get_preferred_size()[0] - 1
+ new_scroll = ui_tools.get_scroll_position(key, self._scroll, page_height, self._last_content_height)
+
+ if self._scroll != new_scroll:
+ self._scroll = new_scroll
+ self.redraw(True)
+ elif key.match('l'):
+ self.set_line_number_visible(not self._show_line_numbers)
+ elif key.match('s'):
+ self.set_comments_visible(not self._show_comments)
+ else:
+ return False
+
+ return True
+
+ def get_help(self):
+ return [
+ ('up arrow', 'scroll up a line', None),
+ ('down arrow', 'scroll down a line', None),
+ ('page up', 'scroll up a page', None),
+ ('page down', 'scroll down a page', None),
+ ('s', 'comment stripping', 'off' if self._show_comments else 'on'),
+ ('l', 'line numbering', 'on' if self._show_line_numbers else 'off'),
+ ('x', 'reset tor (issue sighup)', None),
+ ]
+
+ def draw(self, width, height):
+ if self._torrc_content is None:
+ self.addstr(1, 0, self._torrc_load_error, 'red', curses.A_BOLD)
+ new_content_height = 1
+ else:
+ self._scroll = max(0, min(self._scroll, self._last_content_height - height + 1))
+
+ if not self._show_line_numbers:
+ line_number_offset = 0
+ elif len(self._torrc_content) == 0:
+ line_number_offset = 2
+ else:
+ line_number_offset = int(math.log10(len(self._torrc_content))) + 2
+
+ scroll_offset = 0
+
+ if self._last_content_height > height - 1:
+ scroll_offset = 3
+ self.add_scroll_bar(self._scroll, self._scroll + height - 1, self._last_content_height, 1)
+
+ y = 1 - self._scroll
+ is_multiline = False # true if we're in the middle of a multiline torrc entry
+
+ for line_number, line in enumerate(self._torrc_content):
+ if not self._show_comments:
+ line = line[:line.find('#')].rstrip() if '#' in line else line
+
+ if not line:
+ continue # skip blank lines
+
+ if '#' in line:
+ line, comment = line.split('#', 1)
+ comment = '#' + comment
+ else:
+ comment = ''
+
+ if is_multiline:
+ option, argument = '', line # previous line ended with a '\'
+ elif ' ' not in line.strip():
+ option, argument = line, '' # no argument
+ else:
+ whitespace = ' ' * (len(line) - len(line.strip()))
+ option, argument = line.strip().split(' ', 1)
+ option = whitespace + option + ' '
+
+ is_multiline = line.endswith('\\') # next line's part of a multi-line entry
+
+ if self._show_line_numbers:
+ self.addstr(y, scroll_offset, str(line_number + 1).rjust(line_number_offset - 1), curses.A_BOLD, 'yellow')
+
+ x = line_number_offset + scroll_offset
+ min_x = line_number_offset + scroll_offset
+
+ x, y = self.addstr_wrap(y, x, option, width, min_x, curses.A_BOLD, 'green')
+ x, y = self.addstr_wrap(y, x, argument, width, min_x, curses.A_BOLD, 'cyan')
+ x, y = self.addstr_wrap(y, x, comment, width, min_x, 'white')
+
+ y += 1
+
+ new_content_height = y + self._scroll - 1
+
+ if self.is_title_visible():
+ self.addstr(0, 0, ' ' * width) # clear line
+ location = ' (%s)' % self._torrc_location if self._torrc_location else ''
+ self.addstr(0, 0, 'Tor Configuration File%s:' % location, curses.A_STANDOUT)
+
+ if self._last_content_height != new_content_height:
+ self._last_content_height = new_content_height
+ self.redraw(True)
diff --git a/nyx/torrc_panel.py b/nyx/torrc_panel.py
deleted file mode 100644
index f0f66b4..0000000
--- a/nyx/torrc_panel.py
+++ /dev/null
@@ -1,171 +0,0 @@
-"""
-Panel displaying the torrc or nyxrc with the validation done against it.
-"""
-
-import math
-import curses
-
-from nyx.util import expand_path, msg, panel, tor_controller, ui_tools
-
-from stem import ControllerError
-from stem.control import State
-
-
-class TorrcPanel(panel.Panel):
- """
- Renders the current torrc or nyxrc with syntax highlighting in a scrollable
- area.
- """
-
- def __init__(self, stdscr):
- panel.Panel.__init__(self, stdscr, 'torrc', 0)
-
- self._scroll = 0
- self._show_line_numbers = True # shows left aligned line numbers
- self._show_comments = True # shows comments and extra whitespace
- self._last_content_height = 0
-
- self._torrc_location = None
- self._torrc_content = None
- self._torrc_load_error = None
-
- controller = tor_controller()
- controller.add_status_listener(self.reset_listener)
- self.reset_listener(controller, State.RESET, None)
-
- def reset_listener(self, controller, event_type, _):
- """
- Reloads and displays the torrc on tor reload (sighup) events.
- """
-
- if event_type == State.RESET:
- try:
- self._torrc_location = expand_path(controller.get_info('config-file'))
-
- with open(self._torrc_location) as torrc_file:
- self._torrc_content = [ui_tools.get_printable(line.replace('\t', ' ')).rstrip() for line in torrc_file.readlines()]
- except ControllerError as exc:
- self._torrc_load_error = msg('panel.torrc.unable_to_find_torrc', error = exc)
- self._torrc_location = None
- self._torrc_content = None
- except Exception as exc:
- self._torrc_load_error = msg('panel.torrc.unable_to_load_torrc', error = exc.strerror)
- self._torrc_content = None
-
- def set_comments_visible(self, is_visible):
- """
- Sets if comments and blank lines are shown or stripped.
-
- :var bool is_visible: shows comments if true, strips otherwise
- """
-
- self._show_comments = is_visible
- self.redraw(True)
-
- def set_line_number_visible(self, is_visible):
- """
- Sets if line numbers are shown or hidden.
-
- :var bool is_visible: displays line numbers if true, hides otherwise
- """
-
- self._show_line_numbers = is_visible
- self.redraw(True)
-
- def handle_key(self, key):
- if key.is_scroll():
- page_height = self.get_preferred_size()[0] - 1
- new_scroll = ui_tools.get_scroll_position(key, self._scroll, page_height, self._last_content_height)
-
- if self._scroll != new_scroll:
- self._scroll = new_scroll
- self.redraw(True)
- elif key.match('l'):
- self.set_line_number_visible(not self._show_line_numbers)
- elif key.match('s'):
- self.set_comments_visible(not self._show_comments)
- else:
- return False
-
- return True
-
- def get_help(self):
- return [
- ('up arrow', 'scroll up a line', None),
- ('down arrow', 'scroll down a line', None),
- ('page up', 'scroll up a page', None),
- ('page down', 'scroll down a page', None),
- ('s', 'comment stripping', 'off' if self._show_comments else 'on'),
- ('l', 'line numbering', 'on' if self._show_line_numbers else 'off'),
- ('x', 'reset tor (issue sighup)', None),
- ]
-
- def draw(self, width, height):
- if self._torrc_content is None:
- self.addstr(1, 0, self._torrc_load_error, 'red', curses.A_BOLD)
- new_content_height = 1
- else:
- self._scroll = max(0, min(self._scroll, self._last_content_height - height + 1))
-
- if not self._show_line_numbers:
- line_number_offset = 0
- elif len(self._torrc_content) == 0:
- line_number_offset = 2
- else:
- line_number_offset = int(math.log10(len(self._torrc_content))) + 2
-
- scroll_offset = 0
-
- if self._last_content_height > height - 1:
- scroll_offset = 3
- self.add_scroll_bar(self._scroll, self._scroll + height - 1, self._last_content_height, 1)
-
- y = 1 - self._scroll
- is_multiline = False # true if we're in the middle of a multiline torrc entry
-
- for line_number, line in enumerate(self._torrc_content):
- if not self._show_comments:
- line = line[:line.find('#')].rstrip() if '#' in line else line
-
- if not line:
- continue # skip blank lines
-
- if '#' in line:
- line, comment = line.split('#', 1)
- comment = '#' + comment
- else:
- comment = ''
-
- if is_multiline:
- option, argument = '', line # previous line ended with a '\'
- elif ' ' not in line.strip():
- option, argument = line, '' # no argument
- else:
- whitespace = ' ' * (len(line) - len(line.strip()))
- option, argument = line.strip().split(' ', 1)
- option = whitespace + option + ' '
-
- is_multiline = line.endswith('\\') # next line's part of a multi-line entry
-
- if self._show_line_numbers:
- self.addstr(y, scroll_offset, str(line_number + 1).rjust(line_number_offset - 1), curses.A_BOLD, 'yellow')
-
- x = line_number_offset + scroll_offset
- min_x = line_number_offset + scroll_offset
-
- x, y = self.addstr_wrap(y, x, option, width, min_x, curses.A_BOLD, 'green')
- x, y = self.addstr_wrap(y, x, argument, width, min_x, curses.A_BOLD, 'cyan')
- x, y = self.addstr_wrap(y, x, comment, width, min_x, 'white')
-
- y += 1
-
- new_content_height = y + self._scroll - 1
-
- if self.is_title_visible():
- self.addstr(0, 0, ' ' * width) # clear line
- location = ' (%s)' % self._torrc_location if self._torrc_location else ''
- self.addstr(0, 0, 'Tor Configuration File%s:' % location, curses.A_STANDOUT)
-
- if self._last_content_height != new_content_height:
- self._last_content_height = new_content_height
- self.redraw(True)
diff --git a/nyx/util/log.py b/nyx/util/log.py
index bf9fe82..e4f962b 100644
--- a/nyx/util/log.py
+++ b/nyx/util/log.py
@@ -4,7 +4,7 @@ runlevels.
::
- trace - logs a message at the TRACE runlevel
+ trace - logs a message at the TRACE runlevel
debug - logs a message at the DEBUG runlevel
info - logs a message at the INFO runlevel
notice - logs a message at the NOTICE runlevel
diff --git a/setup.py b/setup.py
index 13ae6af..326cc61 100644
--- a/setup.py
+++ b/setup.py
@@ -99,7 +99,7 @@ setup(
author = nyx.__author__,
author_email = nyx.__contact__,
url = nyx.__url__,
- packages = ['nyx', 'nyx.menu', 'nyx.util'],
+ packages = ['nyx', 'nyx.panel', 'nyx.menu', 'nyx.util'],
keywords = 'tor onion controller',
install_requires = ['stem>=1.4.1'],
package_data = {'nyx': ['settings/*', 'resources/*']},
