sys-proctable 1.2.6 → 1.2.7

data/lib/darwin/sys/proctable.rb

@@ -11,21 +11,32 @@ module Sys
     # There is no constructor
     private_class_method :new
 
-    private
-
     PROC_PIDTASKALLINFO = 2
     PROC_PIDTHREADINFO  = 5
     PROC_PIDLISTTHREADS = 6
 
+    private_constant :PROC_PIDTASKALLINFO
+    private_constant :PROC_PIDTHREADINFO
+    private_constant :PROC_PIDLISTTHREADS
+
     CTL_KERN       = 1
     KERN_PROCARGS  = 38
     KERN_PROCARGS2 = 49
     MAXCOMLEN      = 16
     MAXPATHLEN     = 256
 
+    private_constant :CTL_KERN
+    private_constant :KERN_PROCARGS
+    private_constant :KERN_PROCARGS2
+    private_constant :MAXCOMLEN
+    private_constant :MAXPATHLEN
+
     MAXTHREADNAMESIZE = 64
     PROC_PIDPATHINFO_MAXSIZE = MAXPATHLEN * 4
 
+    private_constant :MAXTHREADNAMESIZE
+    private_constant :PROC_PIDPATHINFO_MAXSIZE
+
     # JRuby/Truffleruby on Mac
     unless defined? FFI::StructLayout::CharArray
       if defined? FFI::StructLayout::CharArrayProxy
@@ -62,6 +73,8 @@ module Sys
       )
     end
 
+    private_constant :ProcBsdInfo
+
     class ProcTaskInfo < FFI::Struct
       layout(
         :pti_virtual_size, :uint64_t,
@@ -85,6 +98,8 @@ module Sys
       )
     end
 
+    private_constant :ProcTaskInfo
+
     class ProcThreadInfo < FFI::Struct
       layout(
         :pth_user_time, :uint64_t,
@@ -101,28 +116,37 @@ module Sys
       )
     end
 
+    private_constant :ProcThreadInfo
+
     # Map the fields from the FFI::Structs to the Sys::ProcTable struct on
     # class load to reduce the amount of objects needing to be generated for
     # each invocation of Sys::ProcTable.ps
-    all_members           = ProcBsdInfo.members + ProcTaskInfo.members + ProcThreadInfo.members
-    PROC_STRUCT_FIELD_MAP = all_members.map { |member|
+    all_members = ProcBsdInfo.members + ProcTaskInfo.members + ProcThreadInfo.members
+
+    PROC_STRUCT_FIELD_MAP = all_members.map do |member|
                               temp = member.to_s.split('_')
                               sproperty = temp.size > 1 ? temp[1..-1].join('_') : temp.first
                               [member, sproperty.to_sym]
-                            }.to_h
+                            end.to_h
 
     class ProcTaskAllInfo < FFI::Struct
       layout(:pbsd, ProcBsdInfo, :ptinfo, ProcTaskInfo)
     end
 
+    private_constant :ProcTaskAllInfo
+
     ffi_lib 'proc'
 
-    attach_function :proc_listallpids, [:pointer, :int], :int
-    attach_function :proc_pidinfo, [:int, :int, :uint64_t, :pointer, :int], :int
+    attach_function :proc_listallpids, %i[pointer int], :int
+    attach_function :proc_pidinfo, %i[int int uint64_t pointer int], :int
 
     ffi_lib FFI::Library::LIBC
 
-    attach_function :sysctl, [:pointer, :uint, :pointer, :pointer, :pointer, :size_t], :int
+    attach_function :sysctl, %i[pointer uint pointer pointer pointer size_t], :int
+
+    private_class_method :proc_listallpids
+    private_class_method :proc_pidinfo
+    private_class_method :sysctl
 
     # These mostly mimic the struct members, but we've added a few custom ones as well.
     @fields = %w[
@@ -136,16 +160,18 @@ module Sys
 
     # Add a couple aliases to make it similar to Linux
     ProcTableStruct = Struct.new("ProcTableStruct", *@fields) do
-      alias vsize virtual_size
-      alias rss resident_size
+      alias_method :vsize, :virtual_size
+      alias_method :rss, :resident_size
     end
 
+    private_constant :ProcTableStruct
+
     ThreadInfoStruct = Struct.new("ThreadInfo", :user_time, :system_time,
       :cpu_usage, :policy, :run_state, :flags, :sleep_time, :curpri,
       :priority, :maxpriority, :name
     )
 
-    public
+    private_constant :ThreadInfoStruct
 
     # Returns an array of fields that each ProcTableStruct will contain. This
     # may be useful if you want to know in advance what fields are available
@@ -222,7 +248,7 @@ module Sys
         array = block_given? ? nil : []
 
         pids.each do |lpid|
-          next unless pid == lpid if pid
+          next if pid && pid != lpid
           info = ProcTaskAllInfo.new
 
           nb = proc_pidinfo(lpid, PROC_PIDTASKALLINFO, 0, info, info.size)
@@ -258,8 +284,6 @@ module Sys
       end
     end
 
-    private
-
     # Pass by reference method that updates the Ruby struct based on the FFI struct.
     #
     def self.apply_info_to_struct(info, struct)
@@ -275,6 +299,8 @@ module Sys
       end
     end
 
+    private_class_method :apply_info_to_struct
+
     # Returns an array of ThreadInfo objects for the given pid.
     #
     def self.get_thread_info(pid, struct, ptinfo)
@@ -292,7 +318,7 @@ module Sys
       max = ptinfo[:pti_threadnum]
       struct[:threadinfo] = []
 
-      0.upto(max-1) do |index|
+      0.upto(max - 1) do |index|
         tinfo = ProcThreadInfo.new
 
         # Use read_array_of_uint64 for compatibility with JRuby if necessary.
@@ -304,7 +330,7 @@ module Sys
 
         if nb <= 0
           if [Errno::EPERM::Errno, Errno::ESRCH::Errno].include?(FFI.errno)
-            return # Either we don't have permission, or the pid no longer exists
+            next # Either we don't have permission, or the pid no longer exists
           else
             raise SystemCallError.new('proc_pidinfo', FFI.errno)
           end
@@ -321,15 +347,21 @@ module Sys
           tinfo[:pth_curpri],
           tinfo[:pth_priority],
           tinfo[:pth_maxpriority],
-          tinfo[:pth_name].to_s,
+          tinfo[:pth_name].to_s
         )
 
         struct[:threadinfo] << tinfo_struct
       end
     end
 
+    private_class_method :get_thread_info
+
     # Get the command line arguments, as well as the environment settings,
     # for the given PID.
+    #--
+    # Note that on Big Sur and later it seems that you cannot get environment
+    # variable information on spawned processes except in certain circumstances,
+    # e.g. SIP has been disabled, the kernel is in debug mode, etc.
     #
     def self.get_cmd_args_and_env(pid, struct)
       len = FFI::MemoryPointer.new(:size_t)
@@ -389,22 +421,23 @@ module Sys
 
       # Extract the full command line and its arguments from the array
       argc.times do
-        cmdline << ' ' + array.shift
+        cmdline << ' ' << array.shift
       end
 
       struct[:cmdline] = cmdline.strip
 
       # Anything remaining at this point is a collection of key=value
       # pairs which we convert into a hash.
-      environ = array.inject({}) do |hash, string|
+      environ = array.each_with_object({}) do |string, hash|
         if string && string.include?('=')
           key, value = string.split('=')
           hash[key] = value
         end
-        hash
       end
 
       struct[:environ] = environ
     end
+
+    private_class_method :get_cmd_args_and_env
   end
 end

data/lib/freebsd/sys/proctable.rb

@@ -77,7 +77,7 @@ module Sys
       layout(
         :ar_ref, :uint,
         :ar_length, :uint,
-        :ar_args, [:uchar,1]
+        :ar_args, [:uchar, 1]
       )
     end
 

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.2.7'.freeze
   end
 end

data/lib/sys/top.rb

@@ -15,7 +15,7 @@ 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