def test_connections(self):
"""
Checks for our control port in the stem.util.proc.connections output if
we have one.
"""
runner = test.runner.get_runner()
if not proc.is_available():
test.runner.skip(self, '(proc unavailable)')
return
elif test.runner.Torrc.PORT not in runner.get_options():
test.runner.skip(self, '(no control port)')
return
elif not test.runner.get_runner().is_ptraceable():
test.runner.skip(self, '(DisableDebuggerAttachment is set)')
return
elif not os.access('/proc/net/tcp', os.R_OK) or not os.access('/proc/net/udp', os.R_OK):
test.runner.skip(self, '(proc lacks read permissions)')
return
# making a controller connection so that we have something to query for
with runner.get_tor_socket():
tor_pid = test.runner.get_runner().get_pid()
for conn in proc.connections(tor_pid):
if ('127.0.0.1', test.runner.CONTROL_PORT) == conn[:2]:
return
self.fail()
def test_get_connections(self):
"""
Checks for our control port in the stem.util.proc.get_connections output if
we have one.
"""
runner = test.runner.get_runner()
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
elif not test.runner.Torrc.PORT in runner.get_options():
test.runner.skip(self, "(no control port)")
return
elif not test.runner.get_runner().is_ptraceable():
test.runner.skip(self, "(DisableDebuggerAttachment is set)")
return
# making a controller connection so that we have something to query for
with runner.get_tor_socket():
tor_pid = test.runner.get_runner().get_pid()
for conn in proc.get_connections(tor_pid):
if ("127.0.0.1", test.runner.CONTROL_PORT) == conn[:2]:
return
self.fail()
def __init__(self, rate):
super(ResourceTracker, self).__init__(rate)
self._resources = None
self._use_proc = proc.is_available(
) # determines if we use proc or ps for lookups
self._failure_count = 0 # number of times in a row we've failed to get results
def test_get_connections(self):
"""
Checks for our control port in the stem.util.proc.get_connections output if
we have one.
"""
runner = test.runner.get_runner()
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
elif not test.runner.Torrc.PORT in runner.get_options():
test.runner.skip(self, "(no control port)")
return
elif not test.runner.get_runner().is_ptraceable():
test.runner.skip(self, "(DisableDebuggerAttachment is set)")
return
# making a controller connection so that we have something to query for
with runner.get_tor_socket():
tor_pid = test.runner.get_runner().get_pid()
for conn in proc.get_connections(tor_pid):
if ("127.0.0.1", test.runner.CONTROL_PORT) == conn[:2]:
return
self.fail()
def test_get_uid(self):
"""
Checks that stem.util.proc.get_uid matches our tor instance's uid.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
tor_pid = test.runner.get_runner().get_pid()
self.assertEquals(os.geteuid(), proc.get_uid(tor_pid))
def test_get_uid(self):
"""
Checks that stem.util.proc.get_uid matches our tor instance's uid.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
tor_pid = test.runner.get_runner().get_pid()
self.assertEquals(os.geteuid(), proc.get_uid(tor_pid))
def test_get_cwd(self):
"""
Checks that stem.util.proc.get_cwd matches our tor instance's cwd.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
elif not test.runner.get_runner().is_ptraceable():
test.runner.skip(self, "(DisableDebuggerAttachment is set)")
return
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))
def test_get_memory_usage(self):
"""
Checks that stem.util.proc.get_memory_usage looks somewhat reasonable.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
tor_pid = test.runner.get_runner().get_pid()
res_size, vir_size = proc.get_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_cwd(self):
"""
Checks that stem.util.proc.get_cwd matches our tor instance's cwd.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
elif not test.runner.get_runner().is_ptraceable():
test.runner.skip(self, "(DisableDebuggerAttachment is set)")
return
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))
def test_get_memory_usage(self):
"""
Checks that stem.util.proc.get_memory_usage looks somewhat reasonable.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
tor_pid = test.runner.get_runner().get_pid()
res_size, vir_size = proc.get_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):
"""
Checks that stem.util.proc.get_stats looks somewhat reasonable.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
tor_pid = test.runner.get_runner().get_pid()
command, utime, stime, start_time = proc.get_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())
def test_get_stats(self):
"""
Checks that stem.util.proc.get_stats looks somewhat reasonable.
"""
if not proc.is_available():
test.runner.skip(self, "(proc unavailable)")
return
tor_pid = test.runner.get_runner().get_pid()
command, utime, stime, start_time = proc.get_stats(tor_pid, 'command', 'utime', 'stime', 'start time')
self.assertEquals('tor', command)
self.assertTrue(utime > 0)
self.assertTrue(stime > 0)
self.assertTrue(start_time > proc.get_system_start_time())
def test_stats(self):
"""
Checks that stem.util.proc.stats looks somewhat reasonable.
"""
if not proc.is_available():
test.runner.skip(self, '(proc unavailable)')
return
tor_cmd = test.runner.get_runner().get_tor_command(True)
tor_pid = test.runner.get_runner().get_pid()
command, utime, stime, start_time = proc.stats(tor_pid, 'command', 'utime', 'stime', 'start time')
self.assertEqual(tor_cmd, command)
self.assertTrue(float(utime) > 0)
self.assertTrue(float(stime) >= 0)
self.assertTrue(float(start_time) > proc.system_start_time())
def __init__(self, processPid, resolveRate):
"""
Initializes a new resolver daemon. When no longer needed it's suggested
that this is stopped.
Arguments:
processPid - pid of the process being tracked
resolveRate - time between resolving resource usage, resolution is
disabled if zero
"""
threading.Thread.__init__(self)
self.setDaemon(True)
self.processPid = processPid
self.resolveRate = resolveRate
self.cpuSampling = 0.0 # latest cpu usage sampling
self.cpuAvg = 0.0 # total average cpu usage
self.memUsage = 0 # last sampled memory usage in bytes
self.memUsagePercentage = 0.0 # percentage cpu usage
# resolves usage via proc results if true, ps otherwise
self._useProc = proc.is_available()
# used to get the deltas when querying cpu time
self._lastCpuTotal = 0
self.lastLookup = -1
self._halt = False # terminates thread if true
self._valLock = threading.RLock()
self._cond = threading.Condition() # used for pausing the thread
# number of successful calls we've made
self._runCount = 0
# sequential times we've failed with this method of resolution
self._failureCount = 0
def __init__(self, processPid, resolveRate):
"""
Initializes a new resolver daemon. When no longer needed it's suggested
that this is stopped.
Arguments:
processPid - pid of the process being tracked
resolveRate - time between resolving resource usage, resolution is
disabled if zero
"""
threading.Thread.__init__(self)
self.setDaemon(True)
self.processPid = processPid
self.resolveRate = resolveRate
self.cpuSampling = 0.0 # latest cpu usage sampling
self.cpuAvg = 0.0 # total average cpu usage
self.memUsage = 0 # last sampled memory usage in bytes
self.memUsagePercentage = 0.0 # percentage cpu usage
# resolves usage via proc results if true, ps otherwise
self._useProc = proc.is_available()
# used to get the deltas when querying cpu time
self._lastCpuTotal = 0
self.lastLookup = -1
self._halt = False # terminates thread if true
self._valLock = threading.RLock()
self._cond = threading.Condition() # used for pausing the thread
# number of successful calls we've made
self._runCount = 0
# sequential times we've failed with this method of resolution
self._failureCount = 0
def getSystemResolvers(osType = None):
"""
Provides the types of connection resolvers available on this operating
system.
Arguments:
osType - operating system type, fetched from the os module if undefined
"""
if osType == None: osType = os.uname()[0]
if osType == "FreeBSD":
resolvers = [Resolver.BSD_SOCKSTAT, Resolver.BSD_PROCSTAT, Resolver.LSOF]
elif osType in ("OpenBSD", "Darwin"):
resolvers = [Resolver.LSOF]
else:
resolvers = [Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS]
# proc resolution, by far, outperforms the others so defaults to this is able
if proc.is_available():
resolvers = [Resolver.PROC] + resolvers
return resolvers
def getProcessName(pid, default=None, cacheFailure=True):
"""
Provides the name associated with the given process id. This isn't available
on all platforms.
Arguments:
pid - process id for the process being returned
default - result if the process name can't be retrieved (raises an
IOError on failure instead if undefined)
cacheFailure - if the lookup fails and there's a default then caches the
default value to prevent further lookups
"""
if pid in PROCESS_NAME_CACHE:
return PROCESS_NAME_CACHE[pid]
processName, raisedExc = "", None
# fetch it from proc contents if available
if proc.is_available():
try:
processName = proc.get_stats(pid, proc.Stat.COMMAND)[0]
except IOError, exc:
raisedExc = exc
def getProcessName(pid, default = None, cacheFailure = True):
"""
Provides the name associated with the given process id. This isn't available
on all platforms.
Arguments:
pid - process id for the process being returned
default - result if the process name can't be retrieved (raises an
IOError on failure instead if undefined)
cacheFailure - if the lookup fails and there's a default then caches the
default value to prevent further lookups
"""
if pid in PROCESS_NAME_CACHE:
return PROCESS_NAME_CACHE[pid]
processName, raisedExc = "", None
# fetch it from proc contents if available
if proc.is_available():
try:
processName = proc.get_stats(pid, proc.Stat.COMMAND)[0]
except IOError, exc:
raisedExc = exc
def __init__(self, rate):
super(ResourceTracker, self).__init__(rate)
self._resources = None
self._use_proc = proc.is_available() # determines if we use proc or ps for lookups
self._failure_count = 0 # number of times in a row we've failed to get results