Example #1
0
File: proc.py Project: ouzel/stem
  def test_get_memory_usage(self, get_lines_mock):
    """
    Tests the get_memory_usage function with a given pid.
    """

    get_lines_mock.side_effect = lambda *params: {
      ('/proc/1111/status', ('VmRSS:', 'VmSize:'), 'memory usage'):
        {'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))
Example #2
0
  def test_get_memory_usage(self):
    """
    Tests the get_memory_usage function with a given pid.
    """

    mocking.mock(proc._get_lines, mocking.return_for_args({
      ('/proc/1111/status', ('VmRSS:', 'VmSize:'), 'memory usage'):
        {'VmRSS:': 'VmRSS: 100 kB', 'VmSize:': 'VmSize: 1800 kB'}
    }))

    self.assertEqual((0, 0), proc.get_memory_usage(0))
    self.assertEqual((100 * 1024, 1800 * 1024), proc.get_memory_usage(1111))
Example #3
0
    def test_get_memory_usage(self, get_lines_mock):
        """
    Tests the get_memory_usage function with a given pid.
    """

        get_lines_mock.side_effect = lambda *params: {
            ('/proc/1111/status', ('VmRSS:', 'VmSize:'), 'memory usage'): {
                '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))
Example #4
0
  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)
Example #5
0
    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)
Example #6
0
    def run(self):
        while not self._halt:
            timeSinceReset = time.time() - self.lastLookup

            if self.resolveRate == 0:
                self._cond.acquire()
                if not self._halt: self._cond.wait(0.2)
                self._cond.release()

                continue
            elif timeSinceReset < self.resolveRate:
                sleepTime = max(0.2, self.resolveRate - timeSinceReset)

                self._cond.acquire()
                if not self._halt: self._cond.wait(sleepTime)
                self._cond.release()

                continue  # done waiting, try again

            newValues = {}
            try:
                if self._useProc:
                    utime, stime, startTime = proc.get_stats(
                        self.processPid, proc.Stat.CPU_UTIME,
                        proc.Stat.CPU_STIME, proc.Stat.START_TIME)
                    totalCpuTime = float(utime) + float(stime)
                    cpuDelta = totalCpuTime - self._lastCpuTotal
                    newValues["cpuSampling"] = cpuDelta / timeSinceReset
                    newValues["cpuAvg"] = totalCpuTime / (time.time() -
                                                          float(startTime))
                    newValues["_lastCpuTotal"] = totalCpuTime

                    memUsage = int(proc.get_memory_usage(self.processPid)[0])
                    totalMemory = proc.get_physical_memory()
                    newValues["memUsage"] = memUsage
                    newValues["memUsagePercentage"] = float(
                        memUsage) / totalMemory
                else:
                    # the ps call formats results as:
                    #
                    #     TIME     ELAPSED   RSS %MEM
                    # 3-08:06:32 21-00:00:12 121844 23.5
                    #
                    # or if Tor has only recently been started:
                    #
                    #     TIME      ELAPSED    RSS %MEM
                    #  0:04.40        37:57  18772  0.9

                    psCall = system.call(
                        "ps -p %s -o cputime,etime,rss,%%mem" %
                        self.processPid)

                    isSuccessful = False
                    if psCall and len(psCall) >= 2:
                        stats = psCall[1].strip().split()

                        if len(stats) == 4:
                            try:
                                totalCpuTime = str_tools.parse_short_time_label(
                                    stats[0])
                                uptime = str_tools.parse_short_time_label(
                                    stats[1])
                                cpuDelta = totalCpuTime - self._lastCpuTotal
                                newValues[
                                    "cpuSampling"] = cpuDelta / timeSinceReset
                                newValues["cpuAvg"] = totalCpuTime / uptime
                                newValues["_lastCpuTotal"] = totalCpuTime

                                newValues["memUsage"] = int(
                                    stats[2]) * 1024  # ps size is in kb
                                newValues["memUsagePercentage"] = float(
                                    stats[3]) / 100.0
                                isSuccessful = True
                            except ValueError, exc:
                                pass

                    if not isSuccessful:
                        raise IOError("unrecognized output from ps: %s" %
                                      psCall)
            except IOError, exc:
                newValues = {}
                self._failureCount += 1

                if self._useProc:
                    if self._failureCount >= 3:
                        # We've failed three times resolving via proc. Warn, and fall back
                        # to ps resolutions.
                        log.info(
                            "Failed three attempts to get process resource usage from proc, falling back to ps (%s)"
                            % exc)

                        self._useProc = False
                        self._failureCount = 1  # prevents lastQueryFailed() from thinking that we succeeded
                    else:
                        # wait a bit and try again
                        log.debug(
                            "Unable to query process resource usage from proc (%s)"
                            % exc)
                        self._cond.acquire()
                        if not self._halt: self._cond.wait(0.5)
                        self._cond.release()
                else:
                    # exponential backoff on making failed ps calls
                    sleepTime = 0.01 * (
                        2**self._failureCount) + self._failureCount
                    log.debug(
                        "Unable to query process resource usage from ps, waiting %0.2f seconds (%s)"
                        % (sleepTime, exc))
                    self._cond.acquire()
                    if not self._halt: self._cond.wait(sleepTime)
                    self._cond.release()

            # sets the new values
            if newValues:
                # If this is the first run then the cpuSampling stat is meaningless
                # (there isn't a previous tick to sample from so it's zero at this
                # point). Setting it to the average, which is a fairer estimate.
                if self.lastLookup == -1:
                    newValues["cpuSampling"] = newValues["cpuAvg"]

                self._valLock.acquire()
                self.cpuSampling = newValues["cpuSampling"]
                self.cpuAvg = newValues["cpuAvg"]
                self.memUsage = newValues["memUsage"]
                self.memUsagePercentage = newValues["memUsagePercentage"]
                self._lastCpuTotal = newValues["_lastCpuTotal"]
                self.lastLookup = time.time()
                self._runCount += 1
                self._failureCount = 0
                self._valLock.release()
Example #7
0
 def run(self):
   while not self._halt:
     timeSinceReset = time.time() - self.lastLookup
     
     if self.resolveRate == 0:
       self._cond.acquire()
       if not self._halt: self._cond.wait(0.2)
       self._cond.release()
       
       continue
     elif timeSinceReset < self.resolveRate:
       sleepTime = max(0.2, self.resolveRate - timeSinceReset)
       
       self._cond.acquire()
       if not self._halt: self._cond.wait(sleepTime)
       self._cond.release()
       
       continue # done waiting, try again
     
     newValues = {}
     try:
       if self._useProc:
         utime, stime, startTime = proc.get_stats(self.processPid, proc.Stat.CPU_UTIME, proc.Stat.CPU_STIME, proc.Stat.START_TIME)
         totalCpuTime = float(utime) + float(stime)
         cpuDelta = totalCpuTime - self._lastCpuTotal
         newValues["cpuSampling"] = cpuDelta / timeSinceReset
         newValues["cpuAvg"] = totalCpuTime / (time.time() - float(startTime))
         newValues["_lastCpuTotal"] = totalCpuTime
         
         memUsage = int(proc.get_memory_usage(self.processPid)[0])
         totalMemory = proc.get_physical_memory()
         newValues["memUsage"] = memUsage
         newValues["memUsagePercentage"] = float(memUsage) / totalMemory
       else:
         # the ps call formats results as:
         # 
         #     TIME     ELAPSED   RSS %MEM
         # 3-08:06:32 21-00:00:12 121844 23.5
         # 
         # or if Tor has only recently been started:
         # 
         #     TIME      ELAPSED    RSS %MEM
         #  0:04.40        37:57  18772  0.9
         
         psCall = system.call("ps -p %s -o cputime,etime,rss,%%mem" % self.processPid)
         
         isSuccessful = False
         if psCall and len(psCall) >= 2:
           stats = psCall[1].strip().split()
           
           if len(stats) == 4:
             try:
               totalCpuTime = str_tools.parse_short_time_label(stats[0])
               uptime = str_tools.parse_short_time_label(stats[1])
               cpuDelta = totalCpuTime - self._lastCpuTotal
               newValues["cpuSampling"] = cpuDelta / timeSinceReset
               newValues["cpuAvg"] = totalCpuTime / uptime
               newValues["_lastCpuTotal"] = totalCpuTime
               
               newValues["memUsage"] = int(stats[2]) * 1024 # ps size is in kb
               newValues["memUsagePercentage"] = float(stats[3]) / 100.0
               isSuccessful = True
             except ValueError, exc: pass
         
         if not isSuccessful:
           raise IOError("unrecognized output from ps: %s" % psCall)
     except IOError, exc:
       newValues = {}
       self._failureCount += 1
       
       if self._useProc:
         if self._failureCount >= 3:
           # We've failed three times resolving via proc. Warn, and fall back
           # to ps resolutions.
           log.info("Failed three attempts to get process resource usage from proc, falling back to ps (%s)" % exc)
           
           self._useProc = False
           self._failureCount = 1 # prevents lastQueryFailed() from thinking that we succeeded
         else:
           # wait a bit and try again
           log.debug("Unable to query process resource usage from proc (%s)" % exc)
           self._cond.acquire()
           if not self._halt: self._cond.wait(0.5)
           self._cond.release()
       else:
         # exponential backoff on making failed ps calls
         sleepTime = 0.01 * (2 ** self._failureCount) + self._failureCount
         log.debug("Unable to query process resource usage from ps, waiting %0.2f seconds (%s)" % (sleepTime, exc))
         self._cond.acquire()
         if not self._halt: self._cond.wait(sleepTime)
         self._cond.release()
     
     # sets the new values
     if newValues:
       # If this is the first run then the cpuSampling stat is meaningless
       # (there isn't a previous tick to sample from so it's zero at this
       # point). Setting it to the average, which is a fairer estimate.
       if self.lastLookup == -1:
         newValues["cpuSampling"] = newValues["cpuAvg"]
       
       self._valLock.acquire()
       self.cpuSampling = newValues["cpuSampling"]
       self.cpuAvg = newValues["cpuAvg"]
       self.memUsage = newValues["memUsage"]
       self.memUsagePercentage = newValues["memUsagePercentage"]
       self._lastCpuTotal = newValues["_lastCpuTotal"]
       self.lastLookup = time.time()
       self._runCount += 1
       self._failureCount = 0
       self._valLock.release()