[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [nyx/master] Centralize pausing in Controller



commit e7385ff70800c162699c72de30822139b053982e
Author: Damian Johnson <atagar@xxxxxxxxxxxxxx>
Date:   Thu Jul 14 10:24:59 2016 -0700

    Centralize pausing in Controller
    
    Pausing is a global state. We never pause only some of our interface, as such
    this belongs in the Controller. There's a couple panels that need special
    handling but otherwise a pretty straight forward move.
---
 nyx/controller.py       | 42 +++++++++++++++++++++++++++++++++---------
 nyx/panel/__init__.py   | 42 ++++--------------------------------------
 nyx/panel/connection.py |  6 ++++--
 nyx/panel/graph.py      | 12 +++++++-----
 nyx/panel/header.py     |  5 +++--
 nyx/panel/log.py        |  5 ++---
 test/panel/header.py    |  1 +
 7 files changed, 54 insertions(+), 59 deletions(-)

diff --git a/nyx/controller.py b/nyx/controller.py
index 964e27d..fc38185 100644
--- a/nyx/controller.py
+++ b/nyx/controller.py
@@ -120,7 +120,8 @@ class Controller(object):
 
     self.quit_signal = False
     self._page = 0
-    self._is_paused = False
+    self._paused = False
+    self._pause_time = -1
     self._force_redraw = False
     self._last_drawn = 0
 
@@ -171,23 +172,46 @@ class Controller(object):
 
   def is_paused(self):
     """
-    True if the interface is paused, false otherwise.
+    Provides if the interface is configured to be paused or not.
+
+    :returns: **True** if the interface is paused and **False** otherwise
     """
 
-    return self._is_paused
+    return self._paused
 
   def set_paused(self, is_pause):
     """
-    Sets the interface to be paused or unpaused.
+    Pauses or unpauses the interface.
+
+    :param bool is_pause: suspends the interface if **True**, resumes it
+      otherwise
     """
 
-    if is_pause != self._is_paused:
-      self._is_paused = is_pause
-      self._force_redraw = True
-      self.header_panel().redraw()
+    if is_pause != self._paused:
+      if is_pause:
+        self._pause_time = time.time()
+
+      # Couple panels have their own pausing behavior. I'll later change this to
+      # a listener approach or someting else that's less hacky.
 
       for panel_impl in self.get_all_panels():
-        panel_impl.set_paused(is_pause)
+        if isinstance(panel_impl, nyx.panel.graph.GraphPanel) or isinstance(panel_impl, nyx.panel.log.LogPanel):
+          panel_impl.set_paused(is_pause)
+
+      self._paused = is_pause
+
+      for panel_impl in self.get_display_panels():
+        panel_impl.redraw()
+
+  def get_pause_time(self):
+    """
+    Provides the time that we were last paused, returning -1 if we've never
+    been paused.
+
+    :returns: **float** with the unix timestamp for when we were last paused
+    """
+
+    return self._pause_time
 
   def header_panel(self):
     return self._header_panel
diff --git a/nyx/panel/__init__.py b/nyx/panel/__init__.py
index ee938dc..1d6ae9f 100644
--- a/nyx/panel/__init__.py
+++ b/nyx/panel/__init__.py
@@ -72,9 +72,6 @@ class Panel(object):
   def __init__(self):
     self._visible = False
 
-    self._paused = False
-    self._pause_time = -1
-
     self._top = 0
     self._left = 0
     self._height = -1
@@ -90,40 +87,6 @@ class Panel(object):
 
     self._visible = is_visible
 
-  def is_paused(self):
-    """
-    Provides if the panel's configured to be paused or not.
-    """
-
-    return self._paused
-
-  def set_paused(self, is_pause):
-    """
-    Toggles if the panel is paused or not. This causes the panel to be redrawn
-    when toggling is pause state unless told to do otherwise. This is
-    important when pausing since otherwise the panel's display could change
-    when redrawn for other reasons.
-
-    Arguments:
-      is_pause        - freezes the state of the pause attributes if true, makes
-                        them editable otherwise
-    """
-
-    if is_pause != self._paused:
-      if is_pause:
-        self._pause_time = time.time()
-
-      self._paused = is_pause
-      self.redraw()
-
-  def get_pause_time(self):
-    """
-    Provides the time that we were last paused, returning -1 if we've never
-    been paused.
-    """
-
-    return self._pause_time
-
   def get_top(self):
     """
     Provides the top position used for subwindows.
@@ -234,10 +197,13 @@ class DaemonPanel(Panel, threading.Thread):
     Performs our _update() action at the given rate.
     """
 
+    import nyx.controller
+
     last_ran = -1
+    nyx_controller = nyx.controller.get_controller()
 
     while not self._halt:
-      if self.is_paused() or (time.time() - last_ran) < self._update_rate:
+      if nyx_controller.is_paused() or (time.time() - last_ran) < self._update_rate:
         with self._pause_condition:
           if not self._halt:
             self._pause_condition.wait(0.2)
diff --git a/nyx/panel/connection.py b/nyx/panel/connection.py
index 8e032e6..bd78a9b 100644
--- a/nyx/panel/connection.py
+++ b/nyx/panel/connection.py
@@ -11,6 +11,7 @@ import collections
 import curses
 import itertools
 
+import nyx.controller
 import nyx.curses
 import nyx.panel
 import nyx.popups
@@ -401,6 +402,7 @@ class ConnectionPanel(nyx.panel.DaemonPanel):
 
   def draw(self, subwindow):
     controller = tor_controller()
+    nyx_controller = nyx.controller.get_controller()
     entries = self._entries
 
     lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in entries]))
@@ -408,8 +410,8 @@ class ConnectionPanel(nyx.panel.DaemonPanel):
     details_offset = DETAILS_HEIGHT + 1 if is_showing_details else 0
     selected, scroll = self._scroller.selection(lines, subwindow.height - details_offset - 1)
 
-    if self.is_paused():
-      current_time = self.get_pause_time()
+    if nyx_controller.is_paused():
+      current_time = nyx_controller.get_pause_time()
     elif not controller.is_alive():
       current_time = controller.connection_time()
     else:
diff --git a/nyx/panel/graph.py b/nyx/panel/graph.py
index 029f417..e5f9cc7 100644
--- a/nyx/panel/graph.py
+++ b/nyx/panel/graph.py
@@ -481,8 +481,9 @@ class GraphPanel(nyx.panel.Panel):
     if not self.displayed_stat:
       return 0
 
+    nyx_controller = nyx.controller.get_controller()
     height = DEFAULT_CONTENT_HEIGHT + self._graph_height
-    accounting_stats = self._accounting_stats if self.is_paused() else self._accounting_stats_paused
+    accounting_stats = self._accounting_stats if nyx_controller.is_paused() else self._accounting_stats_paused
 
     if self.displayed_stat == GraphStat.BANDWIDTH and accounting_stats:
       height += 3
@@ -556,13 +557,13 @@ class GraphPanel(nyx.panel.Panel):
       self._accounting_stats_paused = copy.copy(self._accounting_stats)
       self._stats_paused = dict([(key, type(self._stats[key])(self._stats[key])) for key in self._stats])
 
-    nyx.panel.Panel.set_paused(self, is_pause)
-
   def draw(self, subwindow):
     if not self.displayed_stat:
       return
 
-    if not self.is_paused():
+    nyx_controller = nyx.controller.get_controller()
+
+    if not nyx_controller.is_paused():
       stat = self._stats[self.displayed_stat]
       accounting_stats = self._accounting_stats
     else:
@@ -586,10 +587,11 @@ class GraphPanel(nyx.panel.Panel):
     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:
+      nyx_controller = nyx.controller.get_controller()
       old_accounting_stats = self._accounting_stats
       self._accounting_stats = tor_controller().get_accounting_stats(None)
 
-      if not self.is_paused():
+      if not nyx_controller.is_paused():
         # if we either added or removed accounting info then redraw the whole
         # screen to account for resizing
 
diff --git a/nyx/panel/header.py b/nyx/panel/header.py
index a2a5ae7..5f33f4f 100644
--- a/nyx/panel/header.py
+++ b/nyx/panel/header.py
@@ -148,9 +148,10 @@ class HeaderPanel(nyx.panel.DaemonPanel):
 
     # space available for content
 
+    nyx_controller = nyx.controller.get_controller()
     left_width = max(subwindow.width / 2, 77) if is_wide else subwindow.width
     right_width = subwindow.width - left_width
-    pause_time = self.get_pause_time() if self.is_paused() else None
+    pause_time = nyx_controller.get_pause_time() if nyx_controller.is_paused() else None
 
     _draw_platform_section(subwindow, 0, 0, left_width, vals)
 
@@ -175,7 +176,7 @@ class HeaderPanel(nyx.panel.DaemonPanel):
         _draw_fingerprint_and_fd_usage(subwindow, 0, 3, left_width, vals)
         _draw_flags(subwindow, 0, 4, vals.flags)
 
-    _draw_status(subwindow, 0, self.get_height() - 1, self.is_paused(), self._message, *self._message_attr)
+    _draw_status(subwindow, 0, self.get_height() - 1, nyx_controller.is_paused(), self._message, *self._message_attr)
 
   def reset_listener(self, controller, event_type, _):
     self._update()
diff --git a/nyx/panel/log.py b/nyx/panel/log.py
index 81b7a64..02cd7fe 100644
--- a/nyx/panel/log.py
+++ b/nyx/panel/log.py
@@ -250,17 +250,16 @@ class LogPanel(nyx.panel.DaemonPanel):
     if is_pause:
       self._event_log_paused = self._event_log.clone()
 
-    nyx.panel.Panel.set_paused(self, is_pause)
-
   def draw(self, subwindow):
     scroll = self._scroller.location(self._last_content_height, subwindow.height - 1)
 
+    nyx_controller = nyx.controller.get_controller()
     event_filter = self._filter.clone()
     event_types = list(self._event_types)
     last_content_height = self._last_content_height
     show_duplicates = self._show_duplicates
 
-    event_log = self._event_log_paused if self.is_paused() else self._event_log
+    event_log = self._event_log_paused if nyx_controller.is_paused() else self._event_log
     event_log = filter(lambda entry: event_filter.match(entry.display_message), event_log)
     event_log = filter(lambda entry: not entry.is_duplicate or show_duplicates, event_log)
 
diff --git a/test/panel/header.py b/test/panel/header.py
index 3e47afa..c14b404 100644
--- a/test/panel/header.py
+++ b/test/panel/header.py
@@ -73,6 +73,7 @@ class TestHeaderPanel(unittest.TestCase):
   @patch('nyx.panel.header.tor_controller')
   @patch('nyx.panel.header.Sampling.create')
   def test_rendering_panel(self, sampling_mock, tor_controller_mock, nyx_controller_mock):
+    nyx_controller_mock().is_paused.return_value = False
     nyx_controller_mock().get_page.return_value = 1
     nyx_controller_mock().get_page_count.return_value = 4
     sampling_mock.return_value = test_sampling()



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits