sys-proctable 1.2.6 → 1.3.0

data/lib/linux/sys/proctable/cgroup_entry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sys
   class ProcTable
     # This represents a cgroup entry
@@ -20,7 +22,7 @@ module Sys
       def initialize(string)
         @string = string.chomp
         @fields = @string.split(/:/)
-      rescue
+      rescue StandardError
         @fields = []
       end
 
@@ -32,7 +34,7 @@ module Sys
       # Return sets of subsystems bound to the hierarchy
       def subsystems
         @fields[1].split(/,/)
-      rescue
+      rescue StandardError
         []
       end
 

data/lib/linux/sys/proctable/smaps.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sys
   class ProcTable
     # Smaps represents a process' memory size for all mapped files
@@ -25,7 +27,18 @@ module Sys
     # Example:
     #
     #   smaps = Smaps.new(123, IO.read("/proc/1234/smaps")
-    #     => #<Sys::ProcTable::Smaps:0x007f8ac5930768 @pid=123, @pss=107000, @rss=368000, @uss=96000, @swap=192000, @vss=136752000>
+    #
+    #   # result
+    #
+    #   #<Sys::ProcTable::Smaps:0x007f8ac5930768
+    #     @pid=123,
+    #     @pss=107000,
+    #     @rss=368000,
+    #     @uss=96000,
+    #     @swap=192000,
+    #     @vss=136752000
+    #   >
+    #
     #   smaps.pss  # => 109568
     #   smaps.rss  # => 376832
     #   smaps.uss  # => 98304
@@ -33,7 +46,6 @@ module Sys
     #   smaps.vss  # => 140034048
     #
     class Smaps
-
       # Process ID for this smaps
       attr_reader :pid
 
@@ -51,19 +63,19 @@ module Sys
       # 4k + (4k / 2) + (3k / 3) = 7k
       #
       attr_reader :pss
-      alias_method :proportional_set_size, :pss
+      alias proportional_set_size pss
 
       # Resident set size
       #
       # RSS is the total size of all pages, shared or not, mapped to a process.
       attr_reader :rss
-      alias_method :resident_set_size, :rss
+      alias resident_set_size rss
 
       # Unique set size
       #
       # USS is the total size of all private pages mapped to a process.
       attr_reader :uss
-      alias_method :unique_set_size, :uss
+      alias unique_set_size uss
 
       # Swap
       #
@@ -76,7 +88,7 @@ module Sys
       # lazily loaded, this value represents the total size of all mapped files
       # if they were all loaded.
       attr_reader :vss
-      alias_method :virtual_set_size, :vss
+      alias virtual_set_size vss
 
       # Create a new smaps object
       #
@@ -95,22 +107,22 @@ module Sys
         smaps_contents.each_line { |line| parse_smaps_line(line) }
       end
 
-      alias_method :to_s, :inspect
+      alias to_s inspect
 
       private
 
       def parse_smaps_line(line)
         case line
-        when /^Pss:\s+?(\d+)/
-          @pss += Regexp.last_match[1].to_i * 1000
-        when /^Rss:\s+?(\d+)/
-          @rss += Regexp.last_match[1].to_i * 1000
-        when /^Size:\s+?(\d+)/
-          @vss += Regexp.last_match[1].to_i * 1000
-        when /^Swap:\s+?(\d+)/
-          @swap += Regexp.last_match[1].to_i * 1000
-        when /^Private_(Clean|Dirty):\s+?(\d+)/
-          @uss += Regexp.last_match[2].to_i * 1000
+          when /^Pss:\s+?(\d+)/
+            @pss += Regexp.last_match[1].to_i * 1000
+          when /^Rss:\s+?(\d+)/
+            @rss += Regexp.last_match[1].to_i * 1000
+          when /^Size:\s+?(\d+)/
+            @vss += Regexp.last_match[1].to_i * 1000
+          when /^Swap:\s+?(\d+)/
+            @swap += Regexp.last_match[1].to_i * 1000
+          when /^Private_(Clean|Dirty):\s+?(\d+)/
+            @uss += Regexp.last_match[2].to_i * 1000
         end
       end
     end

data/lib/linux/sys/proctable.rb

@@ -1,23 +1,21 @@
+# frozen_string_literal: true
+
 require 'sys/proctable/version'
 require_relative 'proctable/cgroup_entry'
 require_relative 'proctable/smaps'
 
 # The Sys module serves as a namespace only.
 module Sys
-
   # The ProcTable class encapsulates process table information.
   class ProcTable
-
     # Error typically raised if the ProcTable.ps method fails.
     class Error < StandardError; end
 
     # There is no constructor
     private_class_method :new
 
-    private
-
-    @mem_total = IO.read("/proc/meminfo")[/MemTotal.*/].split[1].to_i * 1024 rescue nil
-    @boot_time = IO.read("/proc/stat")[/btime.*/].split.last.to_i rescue nil
+    @mem_total = File.read("/proc/meminfo")[/MemTotal.*/].split[1].to_i * 1024 rescue nil
+    @boot_time = File.read("/proc/stat")[/btime.*/].split.last.to_i rescue nil
 
     @fields = [
       'cmdline',               # Complete command line
@@ -83,10 +81,10 @@ module Sys
       'smaps'                  # Process memory size for all mapped files
     ]
 
-    public
-
     ProcTableStruct = Struct.new('ProcTableStruct', *@fields)
 
+    private_constant :ProcTableStruct
+
     # In block form, yields a ProcTableStruct for each process entry that you
     # have rights to. This method returns an array of ProcTableStruct's in
     # non-block form.
@@ -121,19 +119,19 @@ module Sys
       array  = block_given? ? nil : []
       struct = nil
 
-      raise TypeError unless pid.is_a?(Numeric) if pid
+      raise TypeError if pid && !pid.is_a?(Numeric)
 
-      Dir.foreach("/proc"){ |file|
+      Dir.foreach("/proc") do |file|
         next if file =~ /\D/ # Skip non-numeric directories
-        next unless file.to_i == pid if pid
+        next if pid && file.to_i != pid
 
         struct = ProcTableStruct.new
 
         # Get /proc/<pid>/cmdline information. Strip out embedded nulls.
         begin
-          data = IO.read("/proc/#{file}/cmdline").tr("\000", ' ').strip
+          data = File.read("/proc/#{file}/cmdline").tr("\000", ' ').strip
           struct.cmdline = data
-        rescue
+        rescue StandardError
           next # Process terminated, on to the next process
         end
 
@@ -146,10 +144,10 @@ module Sys
         struct.environ = {}
 
         begin
-          IO.read("/proc/#{file}/environ").force_encoding("UTF-8").split("\0").each{ |str|
+          File.read("/proc/#{file}/environ").force_encoding("UTF-8").split("\0").each do |str|
             key, value = str.split('=')
             struct.environ[key] = value
-          }
+          end
         rescue Errno::EACCES, Errno::ESRCH, Errno::ENOENT
           # Ignore and move on.
         end
@@ -166,7 +164,7 @@ module Sys
           Dir["/proc/#{file}/fd/*"].each do |fd|
             struct.fd[File.basename(fd)] = File.readlink(fd) rescue nil
           end
-        rescue
+        rescue StandardError
           # Ignore and move on
         end
 
@@ -174,7 +172,7 @@ module Sys
         struct.root = File.readlink("/proc/#{file}/root") rescue nil
 
         # Get /proc/<pid>/stat information
-        stat = IO.read("/proc/#{file}/stat") rescue next
+        stat = File.read("/proc/#{file}/stat") rescue next
 
         # Get number of LWP, one directory for each in /proc/<pid>/task/
         # Every process has at least one thread, so if we fail to read the task directory, set nlwp to 1.
@@ -182,7 +180,7 @@ module Sys
 
         # Get control groups to which the process belongs
         unless cgroup == false
-          struct.cgroup = IO.readlines("/proc/#{file}/cgroup").map { |l| CgroupEntry.new(l) } rescue []
+          struct.cgroup = File.readlines("/proc/#{file}/cgroup").map { |l| CgroupEntry.new(l) } rescue []
         end
 
         # Read smaps, returning a parsable string if we don't have permissions.
@@ -190,12 +188,18 @@ module Sys
         # are true for a file in the /proc fileystem but raises a Errno:EACCESS
         # when your try to read it without permissions.
         unless smaps == false
-          smaps_contents = IO.read("/proc/#{file}/smaps") rescue ""
+          smaps_contents = File.read("/proc/#{file}/smaps") rescue ""
           struct.smaps = Smaps.new(file, smaps_contents)
         end
 
-        # Deal with spaces in comm name. Courtesy of Ara Howard.
-        re = %r/\([^\)]+\)/
+        # Deal with spaces in comm name. This isn't supposed to happen, but in
+        # rare cases - the original offending case was "(xzen thread)" - it can
+        # occur. So we parse it out, replace the spaces with hyphens, and
+        # re-insert it into the stat string so that it splits properly later on.
+        #
+        # Courtesy of Ara Howard.
+        #
+        re = /\([^)]+\)/
         comm = stat[re]
         comm.tr!(' ', '-')
         stat[re] = comm
@@ -203,7 +207,7 @@ module Sys
         stat = stat.split
 
         struct.pid                   = stat[0].to_i
-        struct.comm                  = stat[1].tr('()','') # Remove parens
+        struct.comm                  = stat[1].tr('()', '') # Remove parens
         struct.state                 = stat[2]
         struct.ppid                  = stat[3].to_i
         struct.pgrp                  = stat[4].to_i
@@ -250,16 +254,16 @@ module Sys
 
         # Get /proc/<pid>/status information (name, uid, euid, gid, egid)
         begin
-          IO.foreach("/proc/#{file}/status") do |line|
+          File.foreach("/proc/#{file}/status") do |line|
             case line
               when /Name:\s*?(\w+)/
-                struct.name = $1
+                struct.name = Regexp.last_match(1)
               when /Uid:\s*?(\d+)\s*?(\d+)/
-                struct.uid  = $1.to_i
-                struct.euid = $2.to_i
+                struct.uid  = Regexp.last_match(1).to_i
+                struct.euid = Regexp.last_match(2).to_i
               when /Gid:\s*?(\d+)\s*?(\d+)/
-                struct.gid  = $1.to_i
-                struct.egid = $2.to_i
+                struct.gid  = Regexp.last_match(1).to_i
+                struct.egid = Regexp.last_match(2).to_i
             end
           end
         rescue Errno::ESRCH, Errno::ENOENT
@@ -280,7 +284,7 @@ module Sys
         else
           array << struct
         end
-      }
+      end
 
       pid ? struct : array
     end
@@ -295,21 +299,21 @@ module Sys
     #      puts "Field: #{field}"
     #   }
     #
-    def self.fields
-      @fields
+    class << self
+      attr_reader :fields
     end
 
-    private
-
     # Calculate the percentage of memory usage for the given process.
     #
     def self.get_pctmem(rss)
       return nil unless @mem_total
       page_size = 4096
       rss_total = rss * page_size
-      sprintf("%3.2f", (rss_total.to_f / @mem_total) * 100).to_f
+      format("%3.2f", (rss_total.to_f / @mem_total) * 100).to_f
     end
 
+    private_class_method :get_pctmem
+
     # Calculate the percentage of CPU usage for the given process.
     #
     def self.get_pctcpu(utime, start_time)
@@ -317,7 +321,9 @@ module Sys
       hertz = 100.0
       utime = (utime * 10000).to_f
       stime = (start_time.to_f / hertz) + @boot_time
-      sprintf("%3.2f", (utime / 10000.0) / (Time.now.to_i - stime)).to_f
+      format("%3.2f", (utime / 10000.0) / (Time.now.to_i - stime)).to_f
     end
+
+    private_class_method :get_pctcpu
   end
 end

data/lib/sunos/sys/proctable.rb

@@ -110,7 +110,7 @@ module Sys
         :pr_slptime, Timeval,
         :pr_wtime, Timeval,
         :pr_stoptime, Timeval,
-        :pr_filetime, [Timeval,6],
+        :pr_filetime, [Timeval, 6],
         :pr_minf, :ulong_t,
         :pr_majf, :ulong_t,
         :pr_nswap, :ulong_t,
@@ -343,7 +343,7 @@ module Sys
               env_address += data.length + 1 # Add 1 for the space
             end
           end
-        rescue Errno::EACCES, Errno::EOVERFLOW, EOFError, RangeError
+        rescue Errno::EACCES, Errno::EBADF, Errno::EOVERFLOW, EOFError, RangeError
           # Skip this if we don't have proper permissions, if there's
           # no associated environment, or if there's a largefile issue.
         rescue Errno::ENOENT

data/lib/sys/proctable/version.rb

@@ -1,6 +1,6 @@
 module Sys
   class ProcTable
     # The version of the sys-proctable library
-    VERSION = '1.2.6'.freeze
+    VERSION = '1.3.0'.freeze
   end
 end

data/lib/sys/proctable.rb

@@ -5,8 +5,8 @@ case RbConfig::CONFIG['host_os']
     require_relative '../aix/sys/proctable'
   when /darwin/i
     require_relative '../darwin/sys/proctable'
-  when /freebsd/i
-    require_relative '../freebsd/sys/proctable'
+  when /freebsd|dragonfly/i
+    require_relative '../bsd/sys/proctable'
   when /linux/i
     require_relative '../linux/sys/proctable'
   when /sunos|solaris/i

data/lib/sys/top.rb

@@ -15,18 +15,23 @@ module Sys
     #
     # Exception: the default sort field is 'pid' on AIX, Darwin and Windows.
     #
-    def self.top(num=10, field='pctcpu')
+    def self.top(num = 10, field = 'pctcpu')
       field = field.to_s if field.is_a?(Symbol)
 
       aix = RbConfig::CONFIG['host_os'] =~ /aix/i
       darwin = RbConfig::CONFIG['host_os'] =~ /darwin/i
+      dragonfly = RbConfig::CONFIG['host_os'] =~ /dragonfly/i
 
       # Sort by pid on Windows and AIX by default
       if (File::ALT_SEPARATOR || aix || darwin) && field == 'pctcpu'
         field = 'pid'
       end
 
-      Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+      if dragonfly && field == 'pctcpu'
+        Sys::ProcTable.ps.sort_by{ |obj| obj.lwp.pctcpu }[0..num-1]
+      else
+        Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+      end
     end
   end
 end

data/lib/windows/sys/proctable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'win32ole'
 require 'socket'
 require 'date'
@@ -5,10 +7,8 @@ require 'sys/proctable/version'
 
 # The Sys module serves as a namespace only
 module Sys
-
   # The ProcTable class encapsulates process table information
   class ProcTable
-
     # There is no constructor
     private_class_method :new
 
@@ -77,8 +77,8 @@ module Sys
     # may be useful if you want to know in advance what fields are available
     # without having to perform at least one read of the /proc table.
     #
-    def self.fields
-       @fields
+    class << self
+      attr_reader :fields
     end
 
     # call-seq:
@@ -96,19 +96,21 @@ module Sys
       pid  = kwargs[:pid]
       host = kwargs[:host] || Socket.gethostname
 
-      raise TypeError unless pid.kind_of?(Numeric) if pid
+      if pid && !pid.is_a?(Numeric)
+        raise TypeError
+      end
 
       array  = block_given? ? nil : []
       struct = nil
 
       begin
         wmi = WIN32OLE.connect("winmgmts://#{host}/root/cimv2")
-      rescue WIN32OLERuntimeError => e
-        raise Error, e # Re-raise as ProcTable::Error
+      rescue WIN32OLERuntimeError => err
+        raise Error, err # Re-raise as ProcTable::Error
       else
-        wmi.InstancesOf("Win32_Process").each{ |wproc|
-          if pid
-            next unless wproc.ProcessId == pid
+        wmi.InstancesOf("Win32_Process").each do |wproc|
+          if pid && wproc.ProcessId != pid
+            next
           end
 
           # Some fields are added later, and so are nil initially
@@ -117,7 +119,7 @@ module Sys
             nil, # Added later, based on OS version
             wproc.Name,
             wproc.CreationClassName,
-            self.parse_ms_date(wproc.CreationDate),
+            parse_ms_date(wproc.CreationDate),
             wproc.CSCreationClassName,
             wproc.CSName,
             wproc.Description,
@@ -125,40 +127,40 @@ module Sys
             wproc.ExecutionState,
             wproc.Handle,
             wproc.HandleCount,
-            self.parse_ms_date(wproc.InstallDate),
-            self.convert(wproc.KernelModeTime),
+            parse_ms_date(wproc.InstallDate),
+            convert(wproc.KernelModeTime),
             wproc.MaximumWorkingSetSize,
             wproc.MinimumWorkingSetSize,
             wproc.Name,
             wproc.OSCreationClassName,
             wproc.OSName,
-            self.convert(wproc.OtherOperationCount),
-            self.convert(wproc.OtherTransferCount),
+            convert(wproc.OtherOperationCount),
+            convert(wproc.OtherTransferCount),
             wproc.PageFaults,
             wproc.PageFileUsage,
             wproc.ParentProcessId,
-            self.convert(wproc.PeakPageFileUsage),
-            self.convert(wproc.PeakVirtualSize),
-            self.convert(wproc.PeakWorkingSetSize),
+            convert(wproc.PeakPageFileUsage),
+            convert(wproc.PeakVirtualSize),
+            convert(wproc.PeakWorkingSetSize),
             wproc.Priority,
-            self.convert(wproc.PrivatePageCount),
+            convert(wproc.PrivatePageCount),
             wproc.ProcessId,
             wproc.QuotaNonPagedPoolUsage,
             wproc.QuotaPagedPoolUsage,
             wproc.QuotaPeakNonPagedPoolUsage,
             wproc.QuotaPeakPagedPoolUsage,
-            self.convert(wproc.ReadOperationCount),
-            self.convert(wproc.ReadTransferCount),
+            convert(wproc.ReadOperationCount),
+            convert(wproc.ReadTransferCount),
             wproc.SessionId,
             wproc.Status,
-            self.parse_ms_date(wproc.TerminationDate),
+            parse_ms_date(wproc.TerminationDate),
             wproc.ThreadCount,
-            self.convert(wproc.UserModeTime),
-            self.convert(wproc.VirtualSize),
+            convert(wproc.UserModeTime),
+            convert(wproc.VirtualSize),
             wproc.WindowsVersion,
-            self.convert(wproc.WorkingSetSize),
-            self.convert(wproc.WriteOperationCount),
-            self.convert(wproc.WriteTransferCount)
+            convert(wproc.WorkingSetSize),
+            convert(wproc.WriteOperationCount),
+            convert(wproc.WriteTransferCount)
           )
 
           ###############################################################
@@ -179,30 +181,32 @@ module Sys
           else
             array << struct
           end
-        }
+        end
       end
 
       pid ? struct : array
     end
 
-    private
-
     #######################################################################
     # Converts a string in the format '20040703074625.015625-360' into a
     # Ruby Time object.
     #######################################################################
     def self.parse_ms_date(str)
       return if str.nil?
-      return DateTime.parse(str)
+      DateTime.parse(str)
     end
 
+    private_class_method :parse_ms_date
+
     #####################################################################
     # There is a bug in win32ole where uint64 types are returned as a
     # String instead of a Fixnum.  This method deals with that for now.
     #####################################################################
     def self.convert(str)
       return nil if str.nil? # Return nil, not 0
-      return str.to_i
+      str.to_i
     end
+
+    private_class_method :convert
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rspec'
+require 'sys-proctable'
+require 'sys-top'
+
+RSpec.configure do |config|
+  config.filter_run_excluding(:aix) unless RbConfig::CONFIG['host_os'] =~ /aix/i
+  config.filter_run_excluding(:darwin) unless RbConfig::CONFIG['host_os'] =~ /mac|darwin/i
+  config.filter_run_excluding(:linux) unless RbConfig::CONFIG['host_os'] =~ /linux/i
+  config.filter_run_excluding(:bsd) unless RbConfig::CONFIG['host_os'] =~ /bsd|dragonfly/i
+  config.filter_run_excluding(:freebsd) unless RbConfig::CONFIG['host_os'] =~ /freebsd/i
+  config.filter_run_excluding(:dragonfly) unless RbConfig::CONFIG['host_os'] =~ /dragonfly/i
+  config.filter_run_excluding(:sunos) unless RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
+  config.filter_run_excluding(:windows) unless Gem.win_platform?
+  config.filter_run_excluding(:jruby) if RUBY_PLATFORM == 'java'
+end