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

[tor-commits] [arm/master] Switching graph intervals back to an enum



commit c3729a065931ff13898a8e98807c801bd33e5b99
Author: Damian Johnson <atagar@xxxxxxxxxxxxxx>
Date:   Sun Nov 9 18:19:22 2014 -0800

    Switching graph intervals back to an enum
    
    This isn't a revert, but rather moving the interval back into the panel in a
    way that'll make this easier to maintain. This lets us do all config validation
    in the conf_handler(). That's what it's there for. ;)
---
 arm/config/attributes.cfg |    9 ----
 arm/graph_panel.py        |  108 ++++++++++++++++++++-------------------------
 arm/menu/actions.py       |    6 +--
 3 files changed, 51 insertions(+), 72 deletions(-)

diff --git a/arm/config/attributes.cfg b/arm/config/attributes.cfg
index 7452a71..b592e11 100644
--- a/arm/config/attributes.cfg
+++ b/arm/config/attributes.cfg
@@ -27,15 +27,6 @@ attr.hibernate_color awake => green
 attr.hibernate_color soft => yellow
 attr.hibernate_color hard => red
 
-attr.graph.intervals each second => 1
-attr.graph.intervals 5 seconds => 5
-attr.graph.intervals 30 seconds => 30
-attr.graph.intervals minutely => 60
-attr.graph.intervals 15 minute => 900
-attr.graph.intervals 30 minute => 1800
-attr.graph.intervals hourly => 3600
-attr.graph.intervals daily => 86400
-
 attr.graph.title bandwidth => Bandwidth
 attr.graph.title connections => Connection Count
 attr.graph.title resources => System Resources
diff --git a/arm/graph_panel.py b/arm/graph_panel.py
index 5af3fb0..0210b2e 100644
--- a/arm/graph_panel.py
+++ b/arm/graph_panel.py
@@ -27,8 +27,20 @@ from stem.control import Listener
 from stem.util import conf, enum, log, str_tools, system
 
 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'))
 
+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
@@ -42,20 +54,31 @@ def conf_handler(key, value):
     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('arm', {
   'attr.hibernate_color': {},
-  'attr.graph.intervals': {},
   'attr.graph.title': {},
   'attr.graph.header.primary': {},
   'attr.graph.header.secondary': {},
   'features.graph.height': 7,
-  'features.graph.interval': 'each second',
+  'features.graph.type': GraphStat.BANDWIDTH,
+  'features.graph.interval': Interval.EACH_SECOND,
   'features.graph.bound': Bounds.LOCAL_MAX,
   'features.graph.max_width': 150,
   'features.graph.showIntermediateBounds': True,
-  'features.graph.type': 'bandwidth',
   'features.panels.show.connection': True,
   'features.graph.bw.prepopulate': True,
   'features.graph.bw.transferInBytes': False,
@@ -70,6 +93,8 @@ class Stat(object):
 
   :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 float start_time: unix timestamp for when we started
   :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
   """
@@ -88,17 +113,20 @@ class Stat(object):
       self.total = 0
       self.tick = 0
       self.start_time = time.time()
-      self.values = dict([(i, CONFIG['features.graph.max_width'] * [0]) for i in CONFIG['attr.graph.intervals']])
-      self.max_value = dict([(i, 0) for i in CONFIG['attr.graph.intervals']])
-      self._in_process_value = dict([(i, 0) for i in CONFIG['attr.graph.intervals']])
+      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._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 CONFIG['attr.graph.intervals']:
-      interval_seconds = int(CONFIG['attr.graph.intervals'][interval])
+    for interval in Interval:
+      interval_seconds = INTERVAL_SECONDS[interval]
       self._in_process_value[interval] += new_value
 
       if self.tick % interval_seconds == 0:
@@ -147,7 +175,7 @@ class GraphCategory(object):
     :returns: **str** with our y-axis label
     """
 
-    return ''
+    return str(value)
 
   def bandwidth_event(self, event):
     """
@@ -188,8 +216,6 @@ class BandwidthStats(GraphCategory):
     return str_tools.size_label(value, is_bytes = CONFIG['features.graph.bw.transferInBytes'])
 
   def bandwidth_event(self, event):
-    # scales units from B to KB for graphing
-
     self.primary.update(event.read)
     self.secondary.update(event.written)
 
@@ -244,9 +270,6 @@ class ConnectionStats(GraphCategory):
   Tracks number of inbound and outbound connections.
   """
 
-  def y_axis_label(self, value, is_primary):
-    return str(value)
-
   def bandwidth_event(self, event):
     inbound_count, outbound_count = 0, 0
 
@@ -266,11 +289,8 @@ class ConnectionStats(GraphCategory):
     self.primary.update(inbound_count)
     self.secondary.update(outbound_count)
 
-    avg = self.primary.total / max(1, self.primary.tick)
-    self.primary_header_stats = [str(self.primary.latest_value), ', avg: %s' % avg]
-
-    avg = self.secondary.total / max(1, self.secondary.tick)
-    self.secondary_header_stats = [str(self.secondary.latest_value), ', avg: %s' % avg]
+    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):
@@ -279,18 +299,15 @@ class ResourceStats(GraphCategory):
   """
 
   def y_axis_label(self, value, is_primary):
-    return "%i%%" % value if is_primary else str_tools.size_label(value)
+    return '%i%%' % value if is_primary else str_tools.size_label(value)
 
   def bandwidth_event(self, event):
     resources = arm.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)
 
-    avg = self.primary.total / max(1, self.primary.tick)
-    self.primary_header_stats = ['%0.1f%%' % self.primary.latest_value, ', avg: %0.1f%%' % avg]
-
-    avg = self.secondary.total / max(1, self.secondary.tick)
-    self.secondary_header_stats = [str_tools.size_label(self.secondary.latest_value, 1), ', avg: %s' % str_tools.size_label(avg, 1)]
+    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):
@@ -302,20 +319,11 @@ class GraphPanel(panel.Panel):
   def __init__(self, stdscr):
     panel.Panel.__init__(self, stdscr, 'graph', 0)
 
-    if CONFIG['features.graph.interval'] in CONFIG['attr.graph.intervals']:
-      self.update_interval = CONFIG['features.graph.interval']
-    else:
-      self.update_interval = 'each second'
-      log.warn("'%s' isn't a valid graphing interval, options are: %s" % (CONFIG['features.graph.interval'], ', '.join(CONFIG['attr.graph.intervals'])))
-
-    if CONFIG['features.graph.bound'] in Bounds:
-      self.bounds = CONFIG['features.graph.bound']
-    else:
-      self.bounds = Bounds.LOCAL_MAX
-      log.warn("'%s' isn't a valid graph bounds, options are: %s" % (CONFIG['features.graph.bound'], ', '.join(Bounds)))
+    self.current_display = 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 = max(1, CONFIG['features.graph.height'])
-    self.current_display = None    # label of the stats currently being displayed
     self._accounting_stats = None
     self._last_redraw = 0
 
@@ -330,13 +338,6 @@ class GraphPanel(panel.Panel):
     self.set_pause_attr('stats')
     self.set_pause_attr('_accounting_stats')
 
-    if CONFIG['features.graph.type'] == 'none':
-      self.set_stats(None)
-    elif CONFIG['features.graph.type'] in GraphStat:
-      self.set_stats(CONFIG['features.graph.type'])
-    else:
-      log.warn("'%s' isn't a graph type." % CONFIG['features.graph.type'])
-
     # prepopulates bandwidth values from state file
 
     controller = tor_controller()
@@ -369,7 +370,7 @@ class GraphPanel(panel.Panel):
 
         arm.controller.get_controller().redraw()
 
-    update_rate = int(CONFIG['attr.graph.intervals'][self.update_interval])
+    update_rate = INTERVAL_SECONDS[self.update_interval]
 
     if time.time() - self._last_redraw > update_rate:
       self.redraw(True)
@@ -510,11 +511,10 @@ class GraphPanel(panel.Panel):
     elif key.match('i'):
       # provides menu to pick graph panel update interval
 
-      options = CONFIG['attr.graph.intervals'].keys()
-      selection = arm.popups.show_menu('Update Interval:', options, CONFIG['attr.graph.intervals'].keys().index(self.update_interval))
+      selection = arm.popups.show_menu('Update Interval:', list(Interval), list(Interval).index(self.update_interval))
 
       if selection != -1:
-        self.update_interval = CONFIG['attr.graph.intervals'].keys()[selection]
+        self.update_interval = list(Interval)[selection]
     else:
       return False
 
@@ -632,7 +632,7 @@ class GraphPanel(panel.Panel):
 
     # bottom labeling of x-axis
 
-    interval_sec = int(CONFIG['attr.graph.intervals'][self.update_interval])  # seconds per labeling
+    interval_sec = INTERVAL_SECONDS[self.update_interval]
 
     interval_spacing = 10 if graph_column >= WIDE_LABELING_GRAPH_COL else 5
     units_label, decimal_precision = None, 0
@@ -746,16 +746,6 @@ def prepopulate_from_state(stat):
   bw_read_entries = bw_read_entries[len(bw_read_entries) - entry_count:]
   bw_write_entries = bw_write_entries[len(bw_write_entries) - entry_count:]
 
-  # gets index for 15-minute interval
-
-  interval_index = 0
-
-  for interval_rate in CONFIG['attr.graph.intervals'].values():
-    if int(interval_rate) == 900:
-      break
-    else:
-      interval_index += 1
-
   # fills the graphing parameters with state information
 
   for i in range(entry_count):
diff --git a/arm/menu/actions.py b/arm/menu/actions.py
index 28e4e16..3f70e66 100644
--- a/arm/menu/actions.py
+++ b/arm/menu/actions.py
@@ -19,7 +19,6 @@ from stem.util import conf, str_tools
 
 CONFIG = conf.config_dict('arm', {
   'features.log.showDuplicateEntries': False,
-  'attr.graph.intervals': {},
 })
 
 
@@ -168,9 +167,8 @@ def make_graph_menu(graph_panel):
   interval_menu = arm.menu.item.Submenu("Interval")
   interval_group = arm.menu.item.SelectionGroup(graph_panel.set_update_interval, graph_panel.get_update_interval())
 
-  for interval in CONFIG['attr.graph.intervals']:
-    label = str_tools._to_camel_case(interval, divider = " ")
-    interval_menu.add(arm.menu.item.SelectionMenuItem(label, interval_group, interval))
+  for interval in arm.graph_panel.Interval:
+    interval_menu.add(arm.menu.item.SelectionMenuItem(interval, interval_group, interval))
 
   graph_menu.add(interval_menu)
 

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