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

[tor-commits] [arm/master] Dropping resource tracker's last_query_failed()



commit 07c7847c3eeb8aea09a0b2e2c80cc950e7828871
Author: Damian Johnson <atagar@xxxxxxxxxxxxxx>
Date:   Mon Oct 28 13:25:59 2013 -0700

    Dropping resource tracker's last_query_failed()
    
    Ok, I'm not entirely sure why we had this method. We used to to render 0%
    resource usage when fresh results failed to be fetched. Why not show the last
    results we've seen? If we really want to track something reguarding staleness
    then that's what run_counter() is for.
---
 arm/graphing/resourceStats.py |    4 +++-
 arm/headerPanel.py            |   15 +++++--------
 arm/util/tracker.py           |   49 ++++++++++++++++++-----------------------
 3 files changed, 29 insertions(+), 39 deletions(-)

diff --git a/arm/graphing/resourceStats.py b/arm/graphing/resourceStats.py
index 5be4ba8..352c8ec 100644
--- a/arm/graphing/resourceStats.py
+++ b/arm/graphing/resourceStats.py
@@ -17,6 +17,7 @@ class ResourceStats(graphPanel.GraphStats):
   def __init__(self):
     graphPanel.GraphStats.__init__(self)
     self.queryPid = torTools.getConn().controller.get_pid(None)
+    self.lastCounter = None
 
   def clone(self, newCopy=None):
     if not newCopy: newCopy = ResourceStats()
@@ -46,8 +47,9 @@ class ResourceStats(graphPanel.GraphStats):
     if self.queryPid:
       resourceTracker = arm.util.tracker.get_resource_tracker()
 
-      if resourceTracker and not resourceTracker.last_query_failed():
+      if resourceTracker and resourceTracker.run_counter() != self.lastCounter:
         resources = resourceTracker.get_resource_usage()
+        self.lastCounter = resourceTracker.run_counter()
         primary = resources.cpu_sample * 100  # decimal percentage to whole numbers
         secondary = resources.memory_bytes / 1048576  # translate size to MB so axis labels are short
         self.runCount = resourceTracker.run_counter()
diff --git a/arm/headerPanel.py b/arm/headerPanel.py
index d3a8d9d..3420ade 100644
--- a/arm/headerPanel.py
+++ b/arm/headerPanel.py
@@ -564,16 +564,11 @@ class HeaderPanel(panel.Panel, threading.Thread):
     if self.vals["tor/pid"]:
       resourceTracker = arm.util.tracker.get_resource_tracker()
 
-      if resourceTracker.last_query_failed():
-        self.vals["stat/%torCpu"] = "0"
-        self.vals["stat/rss"] = "0"
-        self.vals["stat/%mem"] = "0"
-      else:
-        resources = resourceTracker.get_resource_usage()
-        self._lastResourceFetch = resourceTracker.run_counter()
-        self.vals["stat/%torCpu"] = "%0.1f" % (100 * resources.cpu_sample)
-        self.vals["stat/rss"] = str(resources.memory_bytes)
-        self.vals["stat/%mem"] = "%0.1f" % (100 * resources.memory_percent)
+      resources = resourceTracker.get_resource_usage()
+      self._lastResourceFetch = resourceTracker.run_counter()
+      self.vals["stat/%torCpu"] = "%0.1f" % (100 * resources.cpu_sample)
+      self.vals["stat/rss"] = str(resources.memory_bytes)
+      self.vals["stat/%mem"] = "%0.1f" % (100 * resources.memory_percent)
 
     # determines the cpu time for the arm process (including user and system
     # time of both the primary and child processes)
diff --git a/arm/util/tracker.py b/arm/util/tracker.py
index 7f8ae02..2e964db 100644
--- a/arm/util/tracker.py
+++ b/arm/util/tracker.py
@@ -19,8 +19,7 @@ Background tasks for gathering informatino about the tor process.
     +- get_connections - provides our latest connection results
 
   ResourceTracker - periodically checks the resource usage of tor
-    |- get_resource_usage - provides our latest resource usage results
-    +- last_query_failed - checks if we failed to fetch newer results
+    +- get_resource_usage - provides our latest resource usage results
 """
 
 import collections
@@ -89,10 +88,10 @@ class Daemon(threading.Thread):
   """
 
   def __init__(self, rate):
-    threading.Thread.__init__(self)
+    super(Daemon, self).__init__()
     self.setDaemon(True)
 
-    self._daemon_lock = threading.RLock()
+    self._process_lock = threading.RLock()
     self._process_pid = None
     self._process_name = None
 
@@ -121,7 +120,7 @@ class Daemon(threading.Thread):
 
         continue  # done waiting, try again
 
-      with self._daemon_lock:
+      with self._process_lock:
         if self._process_pid is not None:
           is_successful = self._task(self._process_pid, self._process_name)
         else:
@@ -193,7 +192,7 @@ class Daemon(threading.Thread):
       self._pause_condition.notifyAll()
 
   def _tor_status_listener(self, controller, event_type, _):
-    with self._daemon_lock:
+    with self._process_lock:
       if not self._halt and event_type in (State.INIT, State.RESET):
         tor_pid = controller.get_pid(None)
         tor_cmd = system.get_name_by_pid(tor_pid) if tor_pid else None
@@ -208,10 +207,10 @@ class ConnectionTracker(Daemon):
   """
 
   def __init__(self):
-    Daemon.__init__(self, CONFIG['queries.connections.rate'])
+    super(ConnectionTracker, self).__init__(CONFIG['queries.connections.rate'])
 
-    self._resolvers = connection.get_system_resolvers()
     self._connections = []
+    self._resolvers = connection.get_system_resolvers()
     self._custom_resolver = None
 
     # Number of times in a row we've either failed with our current resolver or
@@ -228,7 +227,7 @@ class ConnectionTracker(Daemon):
       resolver = self._resolvers[0]
       is_default_resolver = True
     else:
-      return  # nothing to resolve with
+      return False  # nothing to resolve with
 
     try:
       start_time = time.time()
@@ -289,7 +288,7 @@ class ConnectionTracker(Daemon):
     Provides the custom resolver the user has selected. This is **None** if
     we're picking resolvers dynamically.
 
-    :returns: :data:`stem.util.connection.Resolver` we're overwritten to use
+    :returns: :data:`~stem.util.connection.Resolver` we're overwritten to use
     """
 
     return self._custom_resolver
@@ -306,10 +305,10 @@ class ConnectionTracker(Daemon):
 
   def get_connections(self):
     """
-    Provides the last queried connection results, an empty list if resolver
-    has been stopped.
+    Provides a listing of tor's latest connections.
 
-    :returns: **list** of :class:`~stem.util.connection.Connection` we last retrieved
+    :returns: **list** of :class:`~stem.util.connection.Connection` we last
+      retrieved, an empty list if our tracker's been stopped
     """
 
     if self._halt:
@@ -317,15 +316,16 @@ class ConnectionTracker(Daemon):
     else:
       return list(self._connections)
 
+
 class ResourceTracker(Daemon):
   """
   Periodically retrieves the resource usage of tor.
   """
 
   def __init__(self):
-    Daemon.__init__(self, CONFIG['queries.resources.rate'])
+    super(ResourceTracker, self).__init__(CONFIG['queries.resources.rate'])
 
-    self._last_sample = None
+    self._resources = None
 
     # resolves usage via proc results if true, ps otherwise
     self._use_proc = proc.is_available()
@@ -340,20 +340,13 @@ class ResourceTracker(Daemon):
 
   def get_resource_usage(self):
     """
-    Provides the last cached resource usage as a named tuple of the form:
-    (cpuUsage_sampling, cpuUsage_avg, memUsage_bytes, memUsage_percent)
-    """
+    Provides tor's latest resource usage.
 
-    with self._daemon_lock:
-      return self._last_sample if self._last_sample else Resources(0.0, 0.0, 0, 0.0)
-
-  def last_query_failed(self):
-    """
-    Provides true if, since we fetched the currently cached results, we've
-    failed to get new results. False otherwise.
+    :returns: latest :data:`~arm.util.tracker.Resources` we've polled
     """
 
-    return self._failure_count != 0
+    result = self._resources
+    return result if result else Resources(0.0, 0.0, 0, 0.0)
 
   def _task(self, process_pid, process_name):
     if process_pid is None:
@@ -419,7 +412,7 @@ class ResourceTracker(Daemon):
           log.info("Failed three attempts to get process resource usage from proc, falling back to ps (%s)" % exc)
 
           self._use_proc = False
-          self._failure_count = 1 # prevents last_query_failed() from thinking that we succeeded
+          self._failure_count = 0
         else:
           # wait a bit and try again
           log.debug("Unable to query process resource usage from proc (%s)" % exc)
@@ -437,7 +430,7 @@ class ResourceTracker(Daemon):
         new_values["cpuSampling"] = new_values["cpuAvg"]
 
       with self.val_lock:
-        self._last_sample = Resources(new_values["cpuSampling"], new_values["cpuAvg"], new_values["memUsage"], new_values["memUsagePercentage"])
+        self._resources = Resources(new_values["cpuSampling"], new_values["cpuAvg"], new_values["memUsage"], new_values["memUsagePercentage"])
         self._last_cpu_total = new_values["_lastCpuTotal"]
         self.last_lookup = time.time()
         self._failure_count = 0



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