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

[tor-commits] [stem/master] Dropping get_* prefix from proc functions



commit 666a831342cb1bc9311ae6e8767a10c4fd1dac5c
Author: Damian Johnson <atagar@xxxxxxxxxxxxxx>
Date:   Mon Sep 1 16:49:04 2014 -0700

    Dropping get_* prefix from proc functions
    
    Just about all the proc functions started with get_*. Bad habbit from my days
    of doing java. Dropping them, with an alias for the old names for backward
    compatability.
---
 stem/control.py         |    1 +
 stem/util/proc.py       |   50 ++++++++++++++++++++++--------------
 test/integ/util/proc.py |   32 ++++++++++++------------
 test/unit/util/proc.py  |   64 +++++++++++++++++++++++------------------------
 4 files changed, 80 insertions(+), 67 deletions(-)

diff --git a/stem/control.py b/stem/control.py
index 8571a7f..7c5d7bd 100644
--- a/stem/control.py
+++ b/stem/control.py
@@ -128,6 +128,7 @@ If you're fine with allowing your script to raise exceptions then this can be mo
   BaseController - Base controller class asynchronous message handling
     |- msg - communicates with the tor process
     |- is_alive - reports if our connection to tor is open or closed
+    |- connection_time - time when we last connected or disconnected
     |- is_authenticated - checks if we're authenticated to tor
     |- connect - connects or reconnects to tor
     |- close - shuts down our connection to the tor process
diff --git a/stem/util/proc.py b/stem/util/proc.py
index f9b2a59..ac1f6f6 100644
--- a/stem/util/proc.py
+++ b/stem/util/proc.py
@@ -20,18 +20,18 @@ future, use them at your own risk.**
 ::
 
   is_available - checks if proc utilities can be used on this system
-  get_system_start_time - unix timestamp for when the system started
-  get_physical_memory - memory available on this system
-  get_cwd - provides the current working directory for a process
-  get_uid - provides the user id a process is running under
-  get_memory_usage - provides the memory usage of a process
-  get_stats - queries statistics about a process
-  get_file_descriptors_used - number of file descriptors used by a process
-  get_connections - provides the connections made by a process
+  system_start_time - unix timestamp for when the system started
+  physical_memory - memory available on this system
+  cwd - provides the current working directory for a process
+  uid - provides the user id a process is running under
+  memory_usage - provides the memory usage of a process
+  stats - queries statistics about a process
+  file_descriptors_used - number of file descriptors used by a process
+  connections - provides the connections made by a process
 
 .. data:: Stat (enum)
 
-  Types of data available via the :func:`~stem.util.proc.get_stats` function.
+  Types of data available via the :func:`~stem.util.proc.stats` function.
 
   ============== ===========
   Stat           Description
@@ -94,7 +94,7 @@ def is_available():
 
 
 @lru_cache()
-def get_system_start_time():
+def system_start_time():
   """
   Provides the unix time (seconds since epoch) when the system started.
 
@@ -117,7 +117,7 @@ def get_system_start_time():
 
 
 @lru_cache()
-def get_physical_memory():
+def physical_memory():
   """
   Provides the total physical memory on the system in bytes.
 
@@ -139,7 +139,7 @@ def get_physical_memory():
     raise exc
 
 
-def get_cwd(pid):
+def cwd(pid):
   """
   Provides the current working directory for the given process.
 
@@ -167,7 +167,7 @@ def get_cwd(pid):
   return cwd
 
 
-def get_uid(pid):
+def uid(pid):
   """
   Provides the user ID the given process is running under.
 
@@ -192,7 +192,7 @@ def get_uid(pid):
     raise exc
 
 
-def get_memory_usage(pid):
+def memory_usage(pid):
   """
   Provides the memory usage in bytes for the given process.
 
@@ -225,7 +225,7 @@ def get_memory_usage(pid):
     raise exc
 
 
-def get_stats(pid, *stat_types):
+def stats(pid, *stat_types):
   """
   Provides process specific information. See the :data:`~stem.util.proc.Stat`
   enum for valid options.
@@ -281,19 +281,19 @@ def get_stats(pid, *stat_types):
         results.append(str(float(stat_comp[14]) / CLOCK_TICKS))
     elif stat_type == Stat.START_TIME:
       if pid == 0:
-        return get_system_start_time()
+        return system_start_time()
       else:
         # According to documentation, starttime is in field 21 and the unit is
         # jiffies (clock ticks). We divide it for clock ticks, then add the
         # uptime to get the seconds since the epoch.
         p_start_time = float(stat_comp[21]) / CLOCK_TICKS
-        results.append(str(p_start_time + get_system_start_time()))
+        results.append(str(p_start_time + system_start_time()))
 
   _log_runtime(parameter, stat_path, start_time)
   return tuple(results)
 
 
-def get_file_descriptors_used(pid):
+def file_descriptors_used(pid):
   """
   Provides the number of file descriptors currently being used by a process.
 
@@ -318,7 +318,7 @@ def get_file_descriptors_used(pid):
     raise IOError("Unable to check number of file descriptors used: %s" % exc)
 
 
-def get_connections(pid):
+def connections(pid):
   """
   Queries connection related information from the proc contents. This provides
   similar results to netstat, lsof, sockstat, and other connection resolution
@@ -524,3 +524,15 @@ def _log_failure(parameter, exc):
   """
 
   log.debug('proc call failed (%s): %s' % (parameter, exc))
+
+# TODO: drop with stem 2.x
+# We renamed our methods to drop a redundant 'get_*' prefix, so alias the old
+# names for backward compatability.
+
+get_system_start_time = system_start_time
+get_physical_memory = physical_memory
+get_cwd = cwd
+get_uid = uid
+get_memory_usage = memory_usage
+get_stats = stats
+get_connections = connections
diff --git a/test/integ/util/proc.py b/test/integ/util/proc.py
index 8b76dd6..cad0114 100644
--- a/test/integ/util/proc.py
+++ b/test/integ/util/proc.py
@@ -12,9 +12,9 @@ from stem.util import proc
 
 
 class TestProc(unittest.TestCase):
-  def test_get_cwd(self):
+  def test_cwd(self):
     """
-    Checks that stem.util.proc.get_cwd matches our tor instance's cwd.
+    Checks that stem.util.proc.cwd matches our tor instance's cwd.
     """
 
     if not proc.is_available():
@@ -26,11 +26,11 @@ class TestProc(unittest.TestCase):
 
     runner = test.runner.get_runner()
     runner_pid, tor_cwd = runner.get_pid(), runner.get_tor_cwd()
-    self.assertEquals(tor_cwd, proc.get_cwd(runner_pid))
+    self.assertEquals(tor_cwd, proc.cwd(runner_pid))
 
-  def test_get_uid(self):
+  def test_uid(self):
     """
-    Checks that stem.util.proc.get_uid matches our tor instance's uid.
+    Checks that stem.util.proc.uid matches our tor instance's uid.
     """
 
     if not proc.is_available():
@@ -38,11 +38,11 @@ class TestProc(unittest.TestCase):
       return
 
     tor_pid = test.runner.get_runner().get_pid()
-    self.assertEquals(os.geteuid(), proc.get_uid(tor_pid))
+    self.assertEquals(os.geteuid(), proc.uid(tor_pid))
 
-  def test_get_memory_usage(self):
+  def test_memory_usage(self):
     """
-    Checks that stem.util.proc.get_memory_usage looks somewhat reasonable.
+    Checks that stem.util.proc.memory_usage looks somewhat reasonable.
     """
 
     if not proc.is_available():
@@ -50,15 +50,15 @@ class TestProc(unittest.TestCase):
       return
 
     tor_pid = test.runner.get_runner().get_pid()
-    res_size, vir_size = proc.get_memory_usage(tor_pid)
+    res_size, vir_size = proc.memory_usage(tor_pid)
 
     # checks that they're larger than a kilobyte
     self.assertTrue(res_size > 1024)
     self.assertTrue(vir_size > 1024)
 
-  def test_get_stats(self):
+  def test_stats(self):
     """
-    Checks that stem.util.proc.get_stats looks somewhat reasonable.
+    Checks that stem.util.proc.stats looks somewhat reasonable.
     """
 
     if not proc.is_available():
@@ -66,16 +66,16 @@ class TestProc(unittest.TestCase):
       return
 
     tor_pid = test.runner.get_runner().get_pid()
-    command, utime, stime, start_time = proc.get_stats(tor_pid, 'command', 'utime', 'stime', 'start time')
+    command, utime, stime, start_time = proc.stats(tor_pid, 'command', 'utime', 'stime', 'start time')
 
     self.assertEquals('tor', command)
     self.assertTrue(float(utime) > 0)
     self.assertTrue(float(stime) >= 0)
-    self.assertTrue(float(start_time) > proc.get_system_start_time())
+    self.assertTrue(float(start_time) > proc.system_start_time())
 
-  def test_get_connections(self):
+  def test_connections(self):
     """
-    Checks for our control port in the stem.util.proc.get_connections output if
+    Checks for our control port in the stem.util.proc.connections output if
     we have one.
     """
 
@@ -95,7 +95,7 @@ class TestProc(unittest.TestCase):
     with runner.get_tor_socket():
       tor_pid = test.runner.get_runner().get_pid()
 
-      for conn in proc.get_connections(tor_pid):
+      for conn in proc.connections(tor_pid):
         if ('127.0.0.1', test.runner.CONTROL_PORT) == conn[:2]:
           return
 
diff --git a/test/unit/util/proc.py b/test/unit/util/proc.py
index 1786a99..c8defd7 100644
--- a/test/unit/util/proc.py
+++ b/test/unit/util/proc.py
@@ -17,45 +17,45 @@ except ImportError:
 
 class TestProc(unittest.TestCase):
   @patch('stem.util.proc._get_line')
-  def test_get_system_start_time(self, get_line_mock):
+  def test_system_start_time(self, get_line_mock):
     """
-    Tests the get_system_start_time function.
+    Tests the system_start_time function.
     """
 
     get_line_mock.side_effect = lambda *params: {
       ('/proc/stat', 'btime', 'system start time'): 'btime 1001001',
     }[params]
 
-    self.assertEquals(1001001, proc.get_system_start_time())
+    self.assertEquals(1001001, proc.system_start_time())
 
   @patch('stem.util.proc._get_line')
-  def test_get_physical_memory(self, get_line_mock):
+  def test_physical_memory(self, get_line_mock):
     """
-    Tests the get_physical_memory function.
+    Tests the physical_memory function.
     """
 
     get_line_mock.side_effect = lambda *params: {
       ('/proc/meminfo', 'MemTotal:', 'system physical memory'): 'MemTotal:       12345 kB',
     }[params]
 
-    self.assertEquals((12345 * 1024), proc.get_physical_memory())
+    self.assertEquals((12345 * 1024), proc.physical_memory())
 
   @patch('os.readlink')
-  def test_get_cwd(self, readlink_mock):
+  def test_cwd(self, readlink_mock):
     """
-    Tests the get_cwd function with a given pid.
+    Tests the cwd function with a given pid.
     """
 
     readlink_mock.side_effect = lambda param: {
       '/proc/24019/cwd': '/home/directory/TEST'
     }[param]
 
-    self.assertEquals('/home/directory/TEST', proc.get_cwd(24019))
+    self.assertEquals('/home/directory/TEST', proc.cwd(24019))
 
   @patch('stem.util.proc._get_line')
-  def test_get_uid(self, get_line_mock):
+  def test_uid(self, get_line_mock):
     """
-    Tests the get_uid function with a given pid.
+    Tests the uid function with a given pid.
     """
 
     for test_value in [(24019, 11111), (0, 22222)]:
@@ -65,12 +65,12 @@ class TestProc(unittest.TestCase):
         ('/proc/%s/status' % pid, 'Uid:', 'uid'): 'Uid: %s' % uid,
       }[params]
 
-      self.assertEquals(uid, proc.get_uid(pid))
+      self.assertEquals(uid, proc.uid(pid))
 
   @patch('stem.util.proc._get_lines')
-  def test_get_memory_usage(self, get_lines_mock):
+  def test_memory_usage(self, get_lines_mock):
     """
-    Tests the get_memory_usage function with a given pid.
+    Tests the memory_usage function with a given pid.
     """
 
     get_lines_mock.side_effect = lambda *params: {
@@ -78,14 +78,14 @@ class TestProc(unittest.TestCase):
         {'VmRSS:': 'VmRSS: 100 kB', 'VmSize:': 'VmSize: 1800 kB'}
     }[params]
 
-    self.assertEqual((0, 0), proc.get_memory_usage(0))
-    self.assertEqual((100 * 1024, 1800 * 1024), proc.get_memory_usage(1111))
+    self.assertEqual((0, 0), proc.memory_usage(0))
+    self.assertEqual((100 * 1024, 1800 * 1024), proc.memory_usage(1111))
 
   @patch('stem.util.proc._get_line')
-  @patch('stem.util.proc.get_system_start_time', Mock(return_value = 10))
-  def test_get_stats(self, get_line_mock):
+  @patch('stem.util.proc.system_start_time', Mock(return_value = 10))
+  def test_stats(self, get_line_mock):
     """
-    Tests get_stats() with all combinations of stat_type arguments.
+    Tests stats() with all combinations of stat_type arguments.
     """
 
     # list of all combinations of args with respective return values
@@ -105,7 +105,7 @@ class TestProc(unittest.TestCase):
       (stat_path, '24062', 'process '): stat
     }[params]
 
-    self.assertEquals((), proc.get_stats(24062))
+    self.assertEquals((), proc.stats(24062))
 
     for stats in stat_combinations:
       # the stats variable is...
@@ -120,7 +120,7 @@ class TestProc(unittest.TestCase):
         (stat_path, '24062', 'process %s' % ', '.join(args)): stat
       }[params]
 
-      self.assertEquals(response, proc.get_stats(24062, *args))
+      self.assertEquals(response, proc.stats(24062, *args))
 
       # tests the case where pid = 0
 
@@ -141,18 +141,18 @@ class TestProc(unittest.TestCase):
         ('/proc/0/stat', '0', 'process %s' % ', '.join(args)): stat
       }[params]
 
-      self.assertEquals(response, proc.get_stats(0, *args))
+      self.assertEquals(response, proc.stats(0, *args))
 
   @patch('os.listdir')
-  def test_get_file_descriptors_used(self, listdir_mock):
+  def test_file_descriptors_used(self, listdir_mock):
     """
-    Tests the get_file_descriptors_used function.
+    Tests the file_descriptors_used function.
     """
 
     # check that we reject bad pids
 
     for arg in (None, -100, 'hello',):
-      self.assertRaises(IOError, proc.get_file_descriptors_used, arg)
+      self.assertRaises(IOError, proc.file_descriptors_used, arg)
 
     # when proc directory doesn't exist
 
@@ -160,7 +160,7 @@ class TestProc(unittest.TestCase):
     listdir_mock.side_effect = OSError(error_msg)
 
     try:
-      proc.get_file_descriptors_used(2118)
+      proc.file_descriptors_used(2118)
       self.fail("We should raise when listdir() fails")
     except IOError as exc:
       expected = "Unable to check number of file descriptors used: %s" % error_msg
@@ -171,15 +171,15 @@ class TestProc(unittest.TestCase):
     listdir_mock.return_value = ['0', '1', '2', '3', '4', '5']
     listdir_mock.side_effect = None
 
-    self.assertEqual(6, proc.get_file_descriptors_used(2118))
-    self.assertEqual(6, proc.get_file_descriptors_used('2118'))
+    self.assertEqual(6, proc.file_descriptors_used(2118))
+    self.assertEqual(6, proc.file_descriptors_used('2118'))
 
   @patch('os.listdir')
   @patch('os.readlink')
   @patch('stem.util.proc.open', create = True)
-  def test_get_connections(self, open_mock, readlink_mock, listdir_mock):
+  def test_connections(self, open_mock, readlink_mock, listdir_mock):
     """
-    Tests the get_connections function.
+    Tests the connections function.
     """
 
     pid = 1111
@@ -204,11 +204,11 @@ class TestProc(unittest.TestCase):
     }[param]
 
     # tests the edge case of pid = 0
-    self.assertEquals([], proc.get_connections(0))
+    self.assertEquals([], proc.connections(0))
 
     expected_results = [
       ('17.17.17.17', 4369, '34.34.34.34', 8738, 'tcp'),
       ('187.187.187.187', 48059, '204.204.204.204', 52428, 'udp'),
     ]
 
-    self.assertEquals(expected_results, proc.get_connections(pid))
+    self.assertEquals(expected_results, proc.connections(pid))



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