[tor-commits] [arm/master] Finishing arm rewrite [insert fireworks here!]

commit cc9e375a079c7f8816bf0564ad2a82ef1ffb039e Author: Damian Johnson atagar@torproject.org Date: Thu May 19 19:03:58 2011 -0700

Finishing arm rewrite [insert fireworks here!]

This is a full rewrite of the arm controller, the functionality that orchestrates the whole arm UI. It's also last piece of the old codebase to be rewritten... so this is it - I'm done with the refactoring project that's been my main endeavor for the last year!

/me does a not-so-little happy dance :) --- armrc.sample | 9 +- src/cli/configPanel.py | 2 +- src/cli/controller.py | 875 +++++++++++++++++++++----------------------- src/cli/descriptorPopup.py | 5 +- src/cli/popups.py | 51 ++-- src/starter.py | 8 +- 6 files changed, 459 insertions(+), 491 deletions(-)

diff --git a/armrc.sample b/armrc.sample index 58fe5c2..9f75ccc 100644 --- a/armrc.sample +++ b/armrc.sample @@ -35,6 +35,12 @@ features.logFile # this is only displayed when we're running out. features.showFdUsage false

+# Seconds to wait on user input before refreshing content +features.redrawRate 5 + +# Confirms promt to confirm when quiting if true +features.confirmQuit true + # Paremters for the log panel # --------------------------- # showDateDividers @@ -218,8 +224,6 @@ cache.armLog.trimSize 200

# Runlevels at which arm logs its events log.startTime INFO -log.refreshRate DEBUG -log.highCpuUsage WARN log.configEntryNotFound NONE log.configEntryUndefined NOTICE log.configEntryTypeError NOTICE @@ -272,4 +276,5 @@ log.stats.failedPsResolution INFO log.savingDebugLog NOTICE log.fdUsageSixtyPercent NOTICE log.fdUsageNinetyPercent WARN +log.unknownTorPid WARN

diff --git a/src/cli/configPanel.py b/src/cli/configPanel.py index 13e4343..c44d295 100644 --- a/src/cli/configPanel.py +++ b/src/cli/configPanel.py @@ -398,7 +398,7 @@ class ConfigPanel(panel.Panel):

popup.win.refresh()

- key = controller.getScreen().getch() + key = controller.getController().getScreen().getch() if key == curses.KEY_LEFT: selection = max(0, selection - 1) elif key == curses.KEY_RIGHT: selection = min(len(selectionOptions) - 1, selection + 1)

diff --git a/src/cli/controller.py b/src/cli/controller.py index 4916faf..a1ec58a 100644 --- a/src/cli/controller.py +++ b/src/cli/controller.py @@ -1,193 +1,363 @@ -#!/usr/bin/env python -# controller.py -- arm interface (curses monitor for relay status) -# Released under the GPL v3 (http://www.gnu.org/licenses/gpl.html) - """ -Curses (terminal) interface for the arm relay status monitor. +Main interface loop for arm, periodically redrawing the screen and issuing +user input to the proper panels. """

-import os -import math import time import curses +import threading

-import popups -import headerPanel -import graphing.graphPanel -import logPanel -import configPanel -import torrcPanel - +import cli.popups +import cli.headerPanel +import cli.logPanel +import cli.configPanel +import cli.torrcPanel +import cli.graphing.graphPanel +import cli.graphing.bandwidthStats +import cli.graphing.connStats +import cli.graphing.resourceStats import cli.connections.connPanel -import cli.connections.connEntry -import cli.connections.entries -from util import conf, log, connections, hostnames, panel, sysTools, torConfig, torTools, uiTools -import graphing.bandwidthStats -import graphing.connStats -import graphing.resourceStats

-# TODO: controller should be its own object that can be refreshed - until that -# emulating via a 'refresh' flag -REFRESH_FLAG = False +from util import connections, conf, enum, log, panel, sysTools, torConfig, torTools

-def refresh(): - global REFRESH_FLAG - REFRESH_FLAG = True +ARM_CONTROLLER = None

-# new panel params and accessors (this is part of the new controller apis) -PANELS = {} -STDSCR = None -IS_PAUSED = False -PAGE = 0 +CONFIG = {"startup.events": "N3", + "startup.blindModeEnabled": False, + "features.redrawRate": 5, + "features.confirmQuit": True, + "features.graph.type": 1, + "features.graph.bw.prepopulate": True, + "log.startTime": log.INFO, + "log.torEventTypeUnrecognized": log.NOTICE, + "log.configEntryUndefined": log.NOTICE, + "log.unknownTorPid": log.WARN} + +GraphStat = enum.Enum("BANDWIDTH", "CONNECTIONS", "SYSTEM_RESOURCES")

-def getScreen(): - return STDSCR +# maps 'features.graph.type' config values to the initial types +GRAPH_INIT_STATS = {1: GraphStat.BANDWIDTH, 2: GraphStat.CONNECTIONS, 3: GraphStat.SYSTEM_RESOURCES}

-def getPage(): +def getController(): """ - Provides the number belonging to this page. Page numbers start at one. + Provides the arm controller instance. """

- return PAGE + 1 + return ARM_CONTROLLER

-def getPanel(name): +def initController(stdscr, startTime): """ - Provides the panel with the given identifier. + Spawns the controller, and related panels for it.

Arguments: - name - name of the panel to be fetched + stdscr - curses window """

- return PANELS[name] + global ARM_CONTROLLER + config = conf.getConfig("arm") + + # initializes the panels + stickyPanels = [cli.headerPanel.HeaderPanel(stdscr, startTime, config), + LabelPanel(stdscr)] + pagePanels = [] + + # first page: graph and log + expandedEvents = cli.logPanel.expandEvents(CONFIG["startup.events"]) + pagePanels.append([cli.graphing.graphPanel.GraphPanel(stdscr), + cli.logPanel.LogPanel(stdscr, expandedEvents, config)]) + + # second page: connections + if not CONFIG["startup.blindModeEnabled"]: + pagePanels.append([cli.connections.connPanel.ConnectionPanel(stdscr, config)]) + + # third page: config + pagePanels.append([cli.configPanel.ConfigPanel(stdscr, cli.configPanel.State.TOR, config)]) + + # fourth page: torrc + pagePanels.append([cli.torrcPanel.TorrcPanel(stdscr, cli.torrcPanel.Config.TORRC, config)]) + + # initializes the controller + ARM_CONTROLLER = Controller(stdscr, stickyPanels, pagePanels) + + # additional configuration for the graph panel + graphPanel = ARM_CONTROLLER.getPanel("graph") + + # statistical monitors for graph + bwStats = cli.graphing.bandwidthStats.BandwidthStats(config) + graphPanel.addStats(GraphStat.BANDWIDTH, bwStats) + graphPanel.addStats(GraphStat.SYSTEM_RESOURCES, cli.graphing.resourceStats.ResourceStats()) + if not CONFIG["startup.blindModeEnabled"]: + graphPanel.addStats(GraphStat.CONNECTIONS, cli.graphing.connStats.ConnStats()) + + # sets graph based on config parameter + try: + initialStats = GRAPH_INIT_STATS.get(CONFIG["features.graph.type"]) + graphPanel.setStats(initialStats) + except ValueError: pass # invalid stats, maybe connections when in blind mode + + # prepopulates bandwidth values from state file + if CONFIG["features.graph.bw.prepopulate"]: + isSuccessful = bwStats.prepopulateFromState() + if isSuccessful: graphPanel.updateInterval = 4

-def getPanels(page = None): +class LabelPanel(panel.Panel): """ - Provides all panels or all panels from a given page. - - Arguments: - page - page number of the panels to be fetched, all panels if undefined + Panel that just displays a single line of text. """

- panelSet = [] - if page == None: - # fetches all panel names - panelSet = list(PAGE_S) - for pagePanels in PAGES: - panelSet += pagePanels - else: panelSet = PAGES[page - 1] + def __init__(self, stdscr): + panel.Panel.__init__(self, stdscr, "msg", 0, 1) + self.msgText = "" + self.msgAttr = curses.A_NORMAL

- return [getPanel(name) for name in panelSet] - -CONFIRM_QUIT = True -REFRESH_RATE = 5 # seconds between redrawing screen - -# enums for message in control label -CTL_HELP, CTL_PAUSED = range(2) - -# panel order per page -PAGE_S = ["header", "control"] # sticky (ie, always available) page -PAGES = [ - ["graph", "log"], - ["conn"], - ["config"], - ["torrc"]] - -CONFIG = {"features.graph.type": 1, - "queries.refreshRate.rate": 5, - "log.torEventTypeUnrecognized": log.NOTICE, - "features.graph.bw.prepopulate": True, - "log.startTime": log.INFO, - "log.refreshRate": log.DEBUG, - "log.highCpuUsage": log.WARN, - "log.configEntryUndefined": log.NOTICE} + def setMessage(self, msg, attr = None): + """ + Sets the message being displayed by the panel. + + Arguments: + msg - string to be displayed + attr - attribute for the label, normal text if undefined + """ + + if attr == None: attr = curses.A_NORMAL + self.msgText = msg + self.msgAttr = attr + + def draw(self, width, height): + self.addstr(0, 0, self.msgText, self.msgAttr)

-class ControlPanel(panel.Panel): - """ Draws single line label for interface controls. """ +class Controller: + """ + Tracks the global state of the interface + """

- def __init__(self, stdscr, isBlindMode): - panel.Panel.__init__(self, stdscr, "control", 0, 1) - self.msgText = CTL_HELP # message text to be displyed - self.msgAttr = curses.A_NORMAL # formatting attributes - self.page = 1 # page number currently being displayed - self.resolvingCounter = -1 # count of resolver when starting (-1 if we aren't working on a batch) - self.isBlindMode = isBlindMode + def __init__(self, stdscr, stickyPanels, pagePanels): + """ + Creates a new controller instance. Panel lists are ordered as they appear, + top to bottom on the page. + + Arguments: + stdscr - curses window + stickyPanels - panels shown at the top of each page + pagePanels - list of pages, each being a list of the panels on it + """ + + self._screen = stdscr + self._stickyPanels = stickyPanels + self._pagePanels = pagePanels + self._page = 0 + self._isPaused = False + self._forceRedraw = False + self.setMsg() # initializes our control message + + def getScreen(self): + """ + Provides our curses window. + """ + + return self._screen

- def setMsg(self, msgText, msgAttr=curses.A_NORMAL): + def getPage(self): """ - Sets the message and display attributes. If msgType matches CTL_HELP or - CTL_PAUSED then uses the default message for those statuses. + Provides the number belonging to this page. Page numbers start at zero. """

- self.msgText = msgText - self.msgAttr = msgAttr + return self._page

- def revertMsg(self): - self.setMsg(CTL_PAUSED if IS_PAUSED else CTL_HELP) + def nextPage(self): + """ + Increments the page number. + """ + + self._page = (self._page + 1) % len(self._pagePanels) + self._forceRedraw = True + self.setMsg()

- def draw(self, width, height): - msgText = self.msgText - msgAttr = self.msgAttr - barTab = 2 # space between msgText and progress bar - barWidthMax = 40 # max width to progress bar - barWidth = -1 # space between "[ ]" in progress bar (not visible if -1) - barProgress = 0 # cells to fill - - if msgText == CTL_HELP: - msgAttr = curses.A_NORMAL + def prevPage(self): + """ + Decrements the page number. + """ + + self._page = (self._page - 1) % len(self._pagePanels) + self._forceRedraw = True + self.setMsg() + + def isPaused(self): + """ + True if the interface is paused, false otherwise. + """ + + return self._isPaused + + def setPaused(self, isPause): + """ + Sets the interface to be paused or unpaused. + """ + + if isPause != self._isPaused: + self._isPaused = isPause + self._forceRedraw = True + self.setMsg()

- if self.resolvingCounter != -1: - if hostnames.isPaused() or not hostnames.isResolving(): - # done resolving dns batch - self.resolvingCounter = -1 - curses.halfdelay(REFRESH_RATE * 10) # revert to normal refresh rate - else: - batchSize = hostnames.getRequestCount() - self.resolvingCounter - entryCount = batchSize - hostnames.getPendingCount() - if batchSize > 0: progress = 100 * entryCount / batchSize - else: progress = 0 - - additive = "or l " if self.page == 2 else "" - batchSizeDigits = int(math.log10(batchSize)) + 1 - entryCountLabel = ("%%%ii" % batchSizeDigits) % entryCount - #msgText = "Resolving hostnames (%i / %i, %i%%) - press esc %sto cancel" % (entryCount, batchSize, progress, additive) - msgText = "Resolving hostnames (press esc %sto cancel) - %s / %i, %2i%%" % (additive, entryCountLabel, batchSize, progress) - - barWidth = min(barWidthMax, width - len(msgText) - 3 - barTab) - barProgress = barWidth * entryCount / batchSize + for panelImpl in self.getAllPanels(): + panelImpl.setPaused(isPause) + + def getPanel(self, name): + """ + Provides the panel with the given identifier. This returns None if no such + panel exists. + + Arguments: + name - name of the panel to be fetched + """ + + for panelImpl in self.getAllPanels(): + if panelImpl.getName() == name: + return panelImpl + + return None + + def getStickyPanels(self): + """ + Provides the panels visibile at the top of every page. + """ + + return list(self._stickyPanels) + + def getDisplayPanels(self, includeSticky = True): + """ + Provides all panels belonging to the current page and sticky content above + it. This is ordered they way they are presented (top to bottom) on the + page. + + Arguments: + includeSticky - includes sticky panels in the results if true + """ + + if includeSticky: + return self._stickyPanels + self._pagePanels[self._page] + else: + return list(self._pagePanels[self._page]) + + def getDaemonPanels(self): + """ + Provides thread panels. + """ + + threadPanels = [] + for panelImpl in self.getAllPanels(): + if isinstance(panelImpl, threading.Thread): + threadPanels.append(panelImpl) + + return threadPanels + + def getAllPanels(self): + """ + Provides all panels in the interface. + """ + + allPanels = list(self._stickyPanels) + + for page in self._pagePanels: + allPanels += list(page) + + return allPanels + + def requestRedraw(self): + """ + Requests that all content is redrawn when the interface is next rendered. + """ + + self._forceRedraw = True + + def isRedrawRequested(self, clearFlag = False): + """ + True if a full redraw has been requested, false otherwise. + + Arguments: + clearFlag - request clears the flag if true + """ + + returnValue = self._forceRedraw + if clearFlag: self._forceRedraw = False + return returnValue + + def setMsg(self, msg = None, attr = None, redraw = False): + """ + Sets the message displayed in the interfaces control panel. This uses our + default prompt if no arguments are provided. + + Arguments: + msg - string to be displayed + attr - attribute for the label, normal text if undefined + redraw - redraws right away if true, otherwise redraws when display + content is next normally drawn + """ + + if msg == None: + msg = ""

- if self.resolvingCounter == -1: - currentPage = self.page - pageCount = len(PAGES) - - if self.isBlindMode: - if currentPage >= 2: currentPage -= 1 - pageCount -= 1 - - msgText = "page %i / %i - q: quit, p: pause, h: page help" % (currentPage, pageCount) - elif msgText == CTL_PAUSED: - msgText = "Paused" - msgAttr = curses.A_STANDOUT - - self.addstr(0, 0, msgText, msgAttr) - if barWidth > -1: - xLoc = len(msgText) + barTab - self.addstr(0, xLoc, "[", curses.A_BOLD) - self.addstr(0, xLoc + 1, " " * barProgress, curses.A_STANDOUT | uiTools.getColor("red")) - self.addstr(0, xLoc + barWidth + 1, "]", curses.A_BOLD) + if attr == None: + if not self._isPaused: + msg = "page %i / %i - q: quit, p: pause, h: page help" % (self._page + 1, len(self._pagePanels)) + attr = curses.A_NORMAL + else: + msg = "Paused" + attr = curses.A_STANDOUT + + controlPanel = self.getPanel("msg") + controlPanel.setMessage(msg, attr) + + if redraw: controlPanel.redraw(True) + else: self._forceRedraw = True

-def setPauseState(panels, monitorIsPaused, currentPage, overwrite=False): +def shutdownDaemons(): """ - Resets the isPaused state of panels. If overwrite is True then this pauses - reguardless of the monitor is paused or not. + Stops and joins on worker threads. """

- allPanels = list(PAGE_S) - for pagePanels in PAGES: - allPanels += pagePanels + # prevents further worker threads from being spawned + torTools.NO_SPAWN = True + + # stops panel daemons + control = getController() + for panelImpl in control.getDaemonPanels(): panelImpl.stop() + for panelImpl in control.getDaemonPanels(): panelImpl.join() + + # joins on TorCtl event thread + torTools.getConn().close() + + # joins on utility daemon threads - this might take a moment since the + # internal threadpools being joined might be sleeping + resourceTrackers = sysTools.RESOURCE_TRACKERS.values() + resolver = connections.getResolver("tor") if connections.isResolverAlive("tor") else None + for tracker in resourceTrackers: tracker.stop() + if resolver: resolver.stop() # sets halt flag (returning immediately) + for tracker in resourceTrackers: tracker.join() + if resolver: resolver.join() # joins on halted resolver + +def heartbeatCheck(isUnresponsive): + """ + Logs if its been ten seconds since the last BW event. + + Arguments: + isUnresponsive - flag for if we've indicated to be responsive or not + """

- for key in allPanels: panels[key].setPaused(overwrite or monitorIsPaused or (key not in PAGES[currentPage] and key not in PAGE_S)) + conn = torTools.getConn() + lastHeartbeat = conn.getHeartbeat() + if conn.isAlive() and "BW" in conn.getControllerEvents() and lastHeartbeat != 0: + if not isUnresponsive and (time.time() - lastHeartbeat) >= 10: + isUnresponsive = True + log.log(log.NOTICE, "Relay unresponsive (last heartbeat: %s)" % time.ctime(lastHeartbeat)) + elif isUnresponsive and (time.time() - lastHeartbeat) < 10: + # really shouldn't happen (meant Tor froze for a bit) + isUnresponsive = False + log.log(log.NOTICE, "Relay resumed") + + return isUnresponsive

-def connResetListener(conn, eventType): +def connResetListener(_, eventType): """ Pauses connection resolution when tor's shut down, and resumes if started again. @@ -197,369 +367,164 @@ def connResetListener(conn, eventType): resolver = connections.getResolver("tor") resolver.setPaused(eventType == torTools.State.CLOSED)

-def selectiveRefresh(panels, page): - """ - This forces a redraw of content on the currently active page (should be done - after changing pages, popups, or anything else that overwrites panels). +def startTorMonitor(startTime): """ + Initializes the interface and starts the main draw loop.

- for panelKey in PAGES[page]: - panels[panelKey].redraw(True) - -def drawTorMonitor(stdscr, startTime, loggedEvents, isBlindMode): - """ - Starts arm interface reflecting information on provided control port. - - stdscr - curses window - startTime - unix time for when arm was started - loggedEvents - event types we've been configured to log - isBlindMode - flag to indicate if the user's turned off connection lookups + Arguments: + startTime - unix time for when arm was started """

- global PANELS, STDSCR, REFRESH_FLAG, PAGE, IS_PAUSED - STDSCR = stdscr - - # loads config for various interface components + # initializes interface configs config = conf.getConfig("arm") config.update(CONFIG) - graphing.graphPanel.loadConfig(config) - cli.connections.connEntry.loadConfig(config)

- # adds events needed for arm functionality to the torTools REQ_EVENTS mapping - # (they're then included with any setControllerEvents call, and log a more - # helpful error if unavailable) - torTools.REQ_EVENTS["BW"] = "bandwidth graph won't function" + cli.graphing.graphPanel.loadConfig(config) + cli.connections.connEntry.loadConfig(config)

- if not isBlindMode: - torTools.REQ_EVENTS["CIRC"] = "may cause issues in identifying client connections" + # attempts to fetch the tor pid, warning if unsuccessful (this is needed for + # checking its resource usage, among other things) + conn = torTools.getConn() + torPid = conn.getMyPid()

- # pauses/unpauses connection resolution according to if tor's connected or not - torTools.getConn().addStatusListener(connResetListener) + if not torPid: + msg = "Unable to determine Tor's pid. Some information, like its resource usage will be unavailable." + log.log(CONFIG["log.unknownTorPid"], msg)

- curses.halfdelay(REFRESH_RATE * 10) # uses getch call as timer for REFRESH_RATE seconds - try: curses.use_default_colors() # allows things like semi-transparent backgrounds (call can fail with ERR) - except curses.error: pass + # adds events needed for arm functionality to the torTools REQ_EVENTS + # mapping (they're then included with any setControllerEvents call, and log + # a more helpful error if unavailable)

- # attempts to make the cursor invisible (not supported in all terminals) - try: curses.curs_set(0) - except curses.error: pass + torTools.REQ_EVENTS["BW"] = "bandwidth graph won't function"

- # attempts to determine tor's current pid (left as None if unresolveable, logging an error later) - torPid = torTools.getConn().getMyPid() + if not CONFIG["startup.blindModeEnabled"]: + torTools.REQ_EVENTS["CIRC"] = "may cause issues in identifying client connections" + + # Configures connection resoultions. This is paused/unpaused according to + # if Tor's connected or not. + conn.addStatusListener(connResetListener) + + if torPid: + # use the tor pid to help narrow connection results + torCmdName = sysTools.getProcessName(torPid, "tor") + connections.getResolver(torCmdName, torPid, "tor") + else: connections.getResolver("tor") + + # hack to display a better (arm specific) notice if all resolvers fail + connections.RESOLVER_FINAL_FAILURE_MSG += " (connection related portions of the monitor won't function)"

# loads the torrc and provides warnings in case of validation errors try: loadedTorrc = torConfig.getTorrc() loadedTorrc.load(True) loadedTorrc.logValidationIssues() - except: pass - - # minor refinements for connection resolver - if not isBlindMode: - if torPid: - # use the tor pid to help narrow connection results - torCmdName = sysTools.getProcessName(torPid, "tor") - resolver = connections.getResolver(torCmdName, torPid, "tor") - else: - resolver = connections.getResolver("tor") - - # hack to display a better (arm specific) notice if all resolvers fail - connections.RESOLVER_FINAL_FAILURE_MSG += " (connection related portions of the monitor won't function)" - - panels = { - "header": headerPanel.HeaderPanel(stdscr, startTime, config), - "graph": graphing.graphPanel.GraphPanel(stdscr), - "log": logPanel.LogPanel(stdscr, loggedEvents, config)} - - # TODO: later it would be good to set the right 'top' values during initialization, - # but for now this is just necessary for the log panel (and a hack in the log...) - - # TODO: bug from not setting top is that the log panel might attempt to draw - # before being positioned - the following is a quick hack til rewritten - panels["log"].setPaused(True) - - panels["conn"] = cli.connections.connPanel.ConnectionPanel(stdscr, config) - - panels["control"] = ControlPanel(stdscr, isBlindMode) - panels["config"] = configPanel.ConfigPanel(stdscr, configPanel.State.TOR, config) - panels["torrc"] = torrcPanel.TorrcPanel(stdscr, torrcPanel.Config.TORRC, config) - - # provides error if pid coulnd't be determined (hopefully shouldn't happen...) - if not torPid: log.log(log.WARN, "Unable to resolve tor pid, abandoning connection listing") - - # statistical monitors for graph - panels["graph"].addStats("bandwidth", graphing.bandwidthStats.BandwidthStats(config)) - panels["graph"].addStats("system resources", graphing.resourceStats.ResourceStats()) - if not isBlindMode: panels["graph"].addStats("connections", graphing.connStats.ConnStats()) - - # sets graph based on config parameter - graphType = CONFIG["features.graph.type"] - if graphType == 0: panels["graph"].setStats(None) - elif graphType == 1: panels["graph"].setStats("bandwidth") - elif graphType == 2 and not isBlindMode: panels["graph"].setStats("connections") - elif graphType == 3: panels["graph"].setStats("system resources") - - # prepopulates bandwidth values from state file - if CONFIG["features.graph.bw.prepopulate"]: - isSuccessful = panels["graph"].stats["bandwidth"].prepopulateFromState() - if isSuccessful: panels["graph"].updateInterval = 4 - - # tells Tor to listen to the events we're interested - #panels["log"].loggedEvents = loggedEvents # strips any that couldn't be set - panels["log"].setLoggedEvents(loggedEvents) # strips any that couldn't be set + except IOError: pass

# provides a notice about any event types tor supports but arm doesn't - missingEventTypes = logPanel.getMissingEventTypes() + missingEventTypes = cli.logPanel.getMissingEventTypes() + if missingEventTypes: pluralLabel = "s" if len(missingEventTypes) > 1 else "" log.log(CONFIG["log.torEventTypeUnrecognized"], "arm doesn't recognize the following event type%s: %s (log 'UNKNOWN' events to see them)" % (pluralLabel, ", ".join(missingEventTypes)))

- PANELS = panels - - # tells revised panels to run as daemons - panels["header"].start() - panels["log"].start() - panels["conn"].start() + try: + curses.wrapper(drawTorMonitor, startTime) + except KeyboardInterrupt: + pass # skip printing stack trace in case of keyboard interrupt + +def drawTorMonitor(stdscr, startTime): + """ + Main draw loop context.

- isUnresponsive = False # true if it's been over ten seconds since the last BW event (probably due to Tor closing) - isPaused = False # if true updates are frozen - overrideKey = None # immediately runs with this input rather than waiting for the user if set - page = 0 + Arguments: + stdscr - curses window + startTime - unix time for when arm was started + """

- PAGE = page + initController(stdscr, startTime) + control = getController()

# provides notice about any unused config keys - for key in config.getUnusedKeys(): + for key in conf.getConfig("arm").getUnusedKeys(): log.log(CONFIG["log.configEntryUndefined"], "Unused configuration entry: %s" % key)

- lastPerformanceLog = 0 # ensures we don't do performance logging too frequently - redrawStartTime = time.time() + # tells daemon panels to start + for panelImpl in control.getDaemonPanels(): panelImpl.start()

- # TODO: popups need to force the panels it covers to redraw (or better, have - # a global refresh function for after changing pages, popups, etc) - - initTime = time.time() - startTime - log.log(CONFIG["log.startTime"], "arm started (initialization took %0.3f seconds)" % initTime) - - # attributes to give a WARN level event if arm's resource usage is too high - isResourceWarningGiven = False - lastResourceCheck = startTime + # allows for background transparency + try: curses.use_default_colors() + except curses.error: pass

- lastSize = None + # makes the cursor invisible + try: curses.curs_set(0) + except curses.error: pass

- # sets initial visiblity for the pages - for entry in PAGE_S: panels[entry].setVisible(True) + # logs the initialization time + msg = "arm started (initialization took %0.3f seconds)" % (time.time() - startTime) + log.log(CONFIG["log.startTime"], msg)

- for i in range(len(PAGES)): - isVisible = i == page - for entry in PAGES[i]: panels[entry].setVisible(isVisible) + # main draw loop + overrideKey = None # uses this rather than waiting on user input + isUnresponsive = False # flag for heartbeat responsiveness check

- # TODO: come up with a nice, clean method for other threads to immediately - # terminate the draw loop and provide a stacktrace while True: - # tried only refreshing when the screen was resized but it caused a - # noticeable lag when resizing and didn't have an appreciable effect - # on system usage + displayPanels = control.getDisplayPanels() + isUnresponsive = heartbeatCheck(isUnresponsive)

- panel.CURSES_LOCK.acquire() - try: - redrawStartTime = time.time() - - # gives panels a chance to take advantage of the maximum bounds - # originally this checked in the bounds changed but 'recreate' is a no-op - # if panel properties are unchanged and checking every redraw is more - # resilient in case of funky changes (such as resizing during popups) - - # hack to make sure header picks layout before using the dimensions below - #panels["header"].getPreferredSize() - - startY = 0 - for panelKey in PAGE_S[:2]: - #panels[panelKey].recreate(stdscr, -1, startY) - panels[panelKey].setParent(stdscr) - panels[panelKey].setWidth(-1) - panels[panelKey].setTop(startY) - startY += panels[panelKey].getHeight() - - for panelSet in PAGES: - tmpStartY = startY - - for panelKey in panelSet: - #panels[panelKey].recreate(stdscr, -1, tmpStartY) - panels[panelKey].setParent(stdscr) - panels[panelKey].setWidth(-1) - panels[panelKey].setTop(tmpStartY) - tmpStartY += panels[panelKey].getHeight() - - # provides a notice if there's been ten seconds since the last BW event - lastHeartbeat = torTools.getConn().getHeartbeat() - if torTools.getConn().isAlive() and "BW" in torTools.getConn().getControllerEvents() and lastHeartbeat != 0: - if not isUnresponsive and (time.time() - lastHeartbeat) >= 10: - isUnresponsive = True - log.log(log.NOTICE, "Relay unresponsive (last heartbeat: %s)" % time.ctime(lastHeartbeat)) - elif isUnresponsive and (time.time() - lastHeartbeat) < 10: - # really shouldn't happen (meant Tor froze for a bit) - isUnresponsive = False - log.log(log.NOTICE, "Relay resumed") - - # TODO: part two of hack to prevent premature drawing by log panel - if page == 0 and not isPaused: panels["log"].setPaused(False) - - # I haven't the foggiest why, but doesn't work if redrawn out of order... - for panelKey in (PAGE_S + PAGES[page]): - newSize = stdscr.getmaxyx() - isResize = lastSize != newSize - lastSize = newSize - - if panelKey != "control": - panels[panelKey].redraw(isResize) - else: - panels[panelKey].redraw(True) - - stdscr.refresh() - - currentTime = time.time() - if currentTime - lastPerformanceLog >= CONFIG["queries.refreshRate.rate"]: - cpuTotal = sum(os.times()[:3]) - pythonCpuAvg = cpuTotal / (currentTime - startTime) - sysCallCpuAvg = sysTools.getSysCpuUsage() - totalCpuAvg = pythonCpuAvg + sysCallCpuAvg - - if sysCallCpuAvg > 0.00001: - log.log(CONFIG["log.refreshRate"], "refresh rate: %0.3f seconds, average cpu usage: %0.3f%% (python), %0.3f%% (system calls), %0.3f%% (total)" % (currentTime - redrawStartTime, 100 * pythonCpuAvg, 100 * sysCallCpuAvg, 100 * totalCpuAvg)) - else: - # with the proc enhancements the sysCallCpuAvg is usually zero - log.log(CONFIG["log.refreshRate"], "refresh rate: %0.3f seconds, average cpu usage: %0.3f%%" % (currentTime - redrawStartTime, 100 * totalCpuAvg)) - - lastPerformanceLog = currentTime - - # once per minute check if the sustained cpu usage is above 5%, if so - # then give a warning (and if able, some advice for lowering it) - # TODO: disabling this for now (scrolling causes cpu spikes for quick - # redraws, ie this is usually triggered by user input) - if False and not isResourceWarningGiven and currentTime > (lastResourceCheck + 60): - if totalCpuAvg >= 0.05: - msg = "Arm's cpu usage is high (averaging %0.3f%%)." % (100 * totalCpuAvg) - - if not isBlindMode: - msg += " You could lower it by dropping the connection data (running as "arm -b")." - - log.log(CONFIG["log.highCpuUsage"], msg) - isResourceWarningGiven = True - - lastResourceCheck = currentTime - finally: - panel.CURSES_LOCK.release() - - # wait for user keyboard input until timeout (unless an override was set) + # sets panel visability + for panelImpl in control.getAllPanels(): + panelImpl.setVisible(panelImpl in displayPanels) + + # panel placement + occupiedContent = 0 + for panelImpl in displayPanels: + panelImpl.setTop(occupiedContent) + occupiedContent += panelImpl.getHeight() + + # redraws visible content + forceRedraw = control.isRedrawRequested(True) + for panelImpl in displayPanels: + panelImpl.redraw(forceRedraw) + + stdscr.refresh() + + # wait for user keyboard input until timeout, unless an override was set if overrideKey: - key = overrideKey - overrideKey = None + key, overrideKey = overrideKey, None else: + curses.halfdelay(CONFIG["features.redrawRate"] * 10) key = stdscr.getch()

- if key == ord('q') or key == ord('Q'): - quitConfirmed = not CONFIRM_QUIT - + if key == curses.KEY_RIGHT: + control.nextPage() + elif key == curses.KEY_LEFT: + control.prevPage() + elif key == ord('p') or key == ord('P'): + control.setPaused(not control.isPaused()) + elif key == ord('q') or key == ord('Q'): # provides prompt to confirm that arm should exit - if CONFIRM_QUIT: + if CONFIG["features.confirmQuit"]: msg = "Are you sure (q again to confirm)?" - confirmationKey = popups.showMsg(msg, attr = curses.A_BOLD) + confirmationKey = cli.popups.showMsg(msg, attr = curses.A_BOLD) quitConfirmed = confirmationKey in (ord('q'), ord('Q')) + else: quitConfirmed = True

if quitConfirmed: - # quits arm - # very occasionally stderr gets "close failed: [Errno 11] Resource temporarily unavailable" - # this appears to be a python bug: http://bugs.python.org/issue3014 - # (haven't seen this is quite some time... mysteriously resolved?) - - torTools.NO_SPAWN = True # prevents further worker threads from being spawned - - # stops panel daemons - panels["header"].stop() - panels["conn"].stop() - panels["log"].stop() - - panels["header"].join() - panels["conn"].join() - panels["log"].join() - - torTools.getConn().close() # joins on TorCtl event thread - - # joins on utility daemon threads - this might take a moment since - # the internal threadpools being joined might be sleeping - resourceTrackers = sysTools.RESOURCE_TRACKERS.values() - resolver = connections.getResolver("tor") if connections.isResolverAlive("tor") else None - for tracker in resourceTrackers: tracker.stop() - if resolver: resolver.stop() # sets halt flag (returning immediately) - hostnames.stop() # halts and joins on hostname worker thread pool - for tracker in resourceTrackers: tracker.join() - if resolver: resolver.join() # joins on halted resolver - + shutdownDaemons() break - elif key == curses.KEY_LEFT or key == curses.KEY_RIGHT: - # switch page - if key == curses.KEY_LEFT: page = (page - 1) % len(PAGES) - else: page = (page + 1) % len(PAGES) - - # skip connections listing if it's disabled - if page == 1 and isBlindMode: - if key == curses.KEY_LEFT: page = (page - 1) % len(PAGES) - else: page = (page + 1) % len(PAGES) - - # pauses panels that aren't visible to prevent events from accumilating - # (otherwise they'll wait on the curses lock which might get demanding) - setPauseState(panels, isPaused, page) - - # prevents panels on other pages from redrawing - for i in range(len(PAGES)): - isVisible = i == page - for entry in PAGES[i]: panels[entry].setVisible(isVisible) - - PAGE = page - - panels["control"].page = page + 1 - - # TODO: this redraw doesn't seem necessary (redraws anyway after this - # loop) - look into this when refactoring - panels["control"].redraw(True) - - selectiveRefresh(panels, page) - elif key == ord('p') or key == ord('P'): - # toggles update freezing - panel.CURSES_LOCK.acquire() - try: - isPaused = not isPaused - IS_PAUSED = isPaused - setPauseState(panels, isPaused, page) - panels["control"].setMsg(CTL_PAUSED if isPaused else CTL_HELP) - finally: - panel.CURSES_LOCK.release() - - selectiveRefresh(panels, page) elif key == ord('x') or key == ord('X'): # provides prompt to confirm that arm should issue a sighup msg = "This will reset Tor's internal state. Are you sure (x again to confirm)?" - confirmationKey = popups.showMsg(msg, attr = curses.A_BOLD) + confirmationKey = cli.popups.showMsg(msg, attr = curses.A_BOLD)

if confirmationKey in (ord('x'), ord('X')): try: torTools.getConn().reload() except IOError, exc: log.log(log.ERR, "Error detected when reloading tor: %s" % sysTools.getFileErrorMsg(exc)) elif key == ord('h') or key == ord('H'): - overrideKey = popups.showHelpPopup() + overrideKey = cli.popups.showHelpPopup() else: - for pagePanel in getPanels(page + 1): - isKeystrokeConsumed = pagePanel.handleKey(key) + for panelImpl in displayPanels: + isKeystrokeConsumed = panelImpl.handleKey(key) if isKeystrokeConsumed: break - - if REFRESH_FLAG: - REFRESH_FLAG = False - selectiveRefresh(panels, page) - -def startTorMonitor(startTime, loggedEvents, isBlindMode): - try: - curses.wrapper(drawTorMonitor, startTime, loggedEvents, isBlindMode) - except KeyboardInterrupt: - pass # skip printing stack trace in case of keyboard interrupt

diff --git a/src/cli/descriptorPopup.py b/src/cli/descriptorPopup.py index 2a51905..e73e9fc 100644 --- a/src/cli/descriptorPopup.py +++ b/src/cli/descriptorPopup.py @@ -104,7 +104,8 @@ def showDescriptorPopup(connectionPanel): """

# hides the title of the first panel on the page - topPanel = controller.getPanels(controller.getPage())[0] + contorl = controller.getController() + topPanel = control.getDisplayPanels(False)[0] topPanel.setTitleVisible(False) topPanel.redraw(True)

@@ -139,7 +140,7 @@ def showDescriptorPopup(connectionPanel):

try: draw(popup, properties) - key = controller.getScreen().getch() + key = control.getScreen().getch()

if uiTools.isSelectionKey(key) or key in (ord('d'), ord('D')): # closes popup diff --git a/src/cli/popups.py b/src/cli/popups.py index dd56bfa..7ed5302 100644 --- a/src/cli/popups.py +++ b/src/cli/popups.py @@ -4,7 +4,7 @@ Functions for displaying popups in the interface.

import curses

-import controller +import cli.controller

from util import panel, uiTools

@@ -21,10 +21,10 @@ def init(height = -1, width = -1): width - maximum width of the popup """

- topSize = controller.getPanel("header").getHeight() - topSize += controller.getPanel("control").getHeight() + control = cli.controller.getController() + topSize = sum(stickyPanel.getHeight() for stickyPanel in control.getStickyPanels())

- popup = panel.Panel(controller.getScreen(), "popup", topSize, height, width) + popup = panel.Panel(control.getScreen(), "popup", topSize, height, width) popup.setVisible(True)

# Redraws the popup to prepare a subwindow instance. If none is spawned then @@ -41,7 +41,7 @@ def finalize(): the rest of the display. """

- controller.refresh() + cli.controller.getController().requestRedraw() panel.CURSES_LOCK.release()

def inputPrompt(msg, initialValue = ""): @@ -55,11 +55,12 @@ def inputPrompt(msg, initialValue = ""): """

panel.CURSES_LOCK.acquire() - controlPanel = controller.getPanel("control") - controlPanel.setMsg(msg) - controlPanel.redraw(True) - userInput = controlPanel.getstr(0, len(msg), initialValue) - controlPanel.revertMsg() + control = cli.controller.getController() + msgPanel = control.getPanel("msg") + msgPanel.setMessage(msg) + msgPanel.redraw(True) + userInput = msgPanel.getstr(0, len(msg), initialValue) + control.setMsg() panel.CURSES_LOCK.release() return userInput

@@ -75,15 +76,13 @@ def showMsg(msg, maxWait = -1, attr = curses.A_STANDOUT): """

panel.CURSES_LOCK.acquire() - controlPanel = controller.getPanel("control") - controlPanel.setMsg(msg, attr) - controlPanel.redraw(True) + control = cli.controller.getController() + control.setMsg(msg, attr, True)

if maxWait == -1: curses.cbreak() else: curses.halfdelay(maxWait * 10) - keyPress = controller.getScreen().getch() - controlPanel.revertMsg() - curses.halfdelay(controller.REFRESH_RATE * 10) + keyPress = control.getScreen().getch() + control.setMsg() panel.CURSES_LOCK.release()

return keyPress @@ -100,8 +99,8 @@ def showHelpPopup():

exitKey = None try: - pageNum = controller.getPage() - pagePanels = controller.getPanels(pageNum) + control = cli.controller.getController() + pagePanels = control.getDisplayPanels()

# the first page is the only one with multiple panels, and it looks better # with the log entries first, so reversing the order @@ -113,7 +112,7 @@ def showHelpPopup():

# test doing afterward in case of overwriting popup.win.box() - popup.addstr(0, 0, "Page %i Commands:" % pageNum, curses.A_STANDOUT) + popup.addstr(0, 0, "Page %i Commands:" % (control.getPage() + 1), curses.A_STANDOUT)

for i in range(len(helpOptions)): if i / 2 >= height - 2: break @@ -142,8 +141,7 @@ def showHelpPopup():

popup.win.refresh() curses.cbreak() - exitKey = controller.getScreen().getch() - curses.halfdelay(controller.REFRESH_RATE * 10) + exitKey = control.getScreen().getch() finally: finalize()

if not uiTools.isSelectionKey(exitKey) and \ @@ -202,7 +200,7 @@ def showSortDialog(title, options, oldSelection, optionColors):

popup.win.refresh()

- key = controller.getScreen().getch() + key = cli.controller.getController().getScreen().getch() if key == curses.KEY_LEFT: cursorLoc = max(0, cursorLoc - 1) elif key == curses.KEY_RIGHT: @@ -220,8 +218,6 @@ def showSortDialog(title, options, oldSelection, optionColors): selectionOptions.remove(selection) cursorLoc = min(cursorLoc, len(selectionOptions) - 1) elif key == 27: break # esc - cancel - - curses.halfdelay(controller.REFRESH_RATE * 10) # reset normal pausing behavior finally: finalize()

if len(newSelections) == len(oldSelection): @@ -278,7 +274,8 @@ def showMenu(title, options, oldSelection):

try: # hides the title of the first panel on the page - topPanel = controller.getPanels(controller.getPage())[0] + control = cli.controller.getController() + topPanel = control.getDisplayPanels(False)[0] topPanel.setTitleVisible(False) topPanel.redraw(True)

@@ -298,12 +295,10 @@ def showMenu(title, options, oldSelection):

popup.win.refresh()

- key = controller.getScreen().getch() + key = control.getScreen().getch() if key == curses.KEY_UP: selection = max(0, selection - 1) elif key == curses.KEY_DOWN: selection = min(len(options) - 1, selection + 1) elif key == 27: selection, key = -1, curses.KEY_ENTER # esc - cancel - - curses.halfdelay(controller.REFRESH_RATE * 10) # reset normal pausing behavior finally: topPanel.setTitleVisible(True) finalize() diff --git a/src/starter.py b/src/starter.py index be97d0e..84abbca 100644 --- a/src/starter.py +++ b/src/starter.py @@ -295,9 +295,11 @@ if __name__ == '__main__': for utilModule in (util.conf, util.connections, util.hostnames, util.log, util.panel, util.procTools, util.sysTools, util.torConfig, util.torTools, util.uiTools): utilModule.loadConfig(config)

- # overwrites undefined parameters with defaults + # snycs config and parameters, saving changed config options and overwriting + # undefined parameters with defaults for key in param.keys(): if param[key] == None: param[key] = CONFIG[key] + else: config.set(key, str(param[key]))

# validates that input has a valid ip address and port controlAddr = param["startup.interface.ipAddress"] @@ -312,7 +314,7 @@ if __name__ == '__main__':

# validates and expands log event flags try: - expandedEvents = cli.logPanel.expandEvents(param["startup.events"]) + cli.logPanel.expandEvents(param["startup.events"]) except ValueError, exc: for flag in str(exc): print "Unrecognized event flag: %s" % flag @@ -395,5 +397,5 @@ if __name__ == '__main__': procName.renameProcess("arm\0%s" % "\0".join(sys.argv[1:])) except: pass

- cli.controller.startTorMonitor(time.time() - initTime, expandedEvents, param["startup.blindModeEnabled"]) + cli.controller.startTorMonitor(time.time() - initTime)