sys-proctable 1.0.0-universal-darwin → 1.1.0-universal-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d71681f166b70bdec46497d235b4d47c9061d895
-  data.tar.gz: 8b36e0e52bd558ce1f8c610cee8c2952a55136e1
+  metadata.gz: 138368be13088153dc725009fa1921edf64a7a63
+  data.tar.gz: a046d5a49a5071add7cb27ca153692dacf5234ff
 SHA512:
-  metadata.gz: 056009b1616215f1f795596cb11ce97a16da140549f7ce4494fbd150be9c46fb3e0b13eaf69fbf84ab3516d0a00f725713e1ef51a131d9d8bd8c8f4cf1b9529c
-  data.tar.gz: 1ccc358831b19224de154589c00e99e8a87a335fec8b0a66cb57052fc064bd2fc2dd57b282d4ebbefddb44fb5c89418f94278df0dacb8d5e1e756818df61bd3b
+  metadata.gz: 0a75f3fc8d2190f04bf05e9ee0859a9c1e91321eb08980af50a5f990c93790f3482edb1c3218f6557e9667d565268d0a69352916898276738fbc2d45e8afaa1f
+  data.tar.gz: c758a8a578c3ec13230b88f2d5801516ce57fee59d6352df1f7fcd2b6419046ec946d8e9eeaf0d9e281c588a1927bf54d3d74929add706fa0450f67d116efc71

data/CHANGES

@@ -1,6 +1,16 @@
+== 1.1.0 - 27-Jun-2016
+* License was changed to Apache 2.0.
+* The OS X version now requires OS X 10.7 or later.
+* Scrapped the C implementation for OS X, and replaced it with a libproc wrapper
+  using FFI, so it is now pure Ruby. Note that some new struct members have been
+  added, while others have been dropped. This includes pctcpu, so Sys::Top does
+  not work at the moment.
+* Rakefile updates to accomodate the changes for OS X.
+* Some test suite updates and refactoring.
+
 == 1.0.0 - 11-Jan-2016
 * Added smaps information for Linux. Thanks go to Joe Rafaniello for the patch.
-* This is not really a major release. I just ran out of version numbers.
+* This really should not have been a major release, sorry.
 
 == 0.9.9 - 8-Nov-2015
 * Added support for cgroups on Linux. Thanks go to Dennis Günnewig for the patch.

data/MANIFEST

@@ -11,14 +11,13 @@
 * doc/top.txt
 * doc/windows.txt
 * example/example_ps.rb
-* ext/darwin/extconf.rb
-* ext/darwin/sys/proctable.c
 * ext/hpux/extconf.rb
 * ext/hpux/sys/proctable.c
 * lib/sys-proctable.rb
 * lib/sys/top.rb
 * lib/sys/proctable/version.rb
 * lib/aix/sys/proctable.rb
+* lib/darwin/sys/proctable.rb
 * lib/freebsd/sys/proctable.rb
 * lib/linux/sys/proctable.rb
 * lib/sunos/sys/proctable.rb

data/README

@@ -10,7 +10,7 @@
 * FreeBSD
 * Solaris 8+
 * HP-UX 10+
-* OS X 10.4+
+* OS X 10.7+
 * AIX 5.3+
 
 == Installation
@@ -22,6 +22,7 @@
   gem install sys-proctable --platform sunos   # Solaris
   gem install sys-proctable --platform linux   # Linux
   gem install sys-proctable --platform freebsd # FreeBSD
+  gem install sys-proctable --platform darwin  # OS X
 
 == Synopsis
   require 'sys/proctable'
@@ -60,16 +61,13 @@
   The cmdline member on Solaris is limited to 80 characters unless you (or
   your program) own the process. This is a Solaris design flaw/feature.
 
-=== Thread Safety
-  I am not currently using a thread-safe version of readdir() for versions
-  of this library that use C. I am not especially concerned about it either.
-  If you are trying to read information out of /proc from different threads
-  at the same time there is something seriously wrong with your code logic.
-  Using readdir_r() still won't solve all potential thread safety issues anyway.
+=== OS X
+  The libproc interface is used. That means you will only get list of
+  processes that you have access to. To get a full listing, run as root.
 
 == Future Plans
   Add support for NetBSD and OpenBSD.
-  Convert existing C code to FFI.
+  Convert remaining C code (just HP-UX at this point) to FFI.
 
 == Acknowledgements
   This library was originally based on the Perl module Proc::ProcessTable
@@ -87,7 +85,7 @@
   debugging help.
    
   Thanks go to David Felstead for the original OS X code. Thanks also go
-  to Matthias Zirnstein for adding cmdline support for OS X.
+  to Matthias Zirnstein for adding the original cmdline support for OS X.
 
   Finally I'd like to thank all the folks who have submitted bug reports
   and/or patches.
@@ -102,17 +100,11 @@
   including platform specific notes and issues.
 
 == License
-  Artistic 2.0
+  Apache 2.0
     
 == Copyright
   (C) 2003-2016 Daniel J. Berger
   All Rights Reserved.
 
-== Contributions
-  Although this library is free, please consider having your company
-  setup a gittip if used by your company professionally.
-
-  http://www.gittip.com/djberg96/
-
 == Author
   Daniel J. Berger

data/Rakefile

@@ -27,15 +27,12 @@ task :build => [:clean] do
   end
 
   case CONFIG['host_os']
-    when /darwin/i
-      dir = 'ext/darwin'
-      ext = '.bundle'
     when /hpux/i
       dir = 'ext/hpux'
       ext = '.sl'
   end
 
-  if CONFIG['host_os'] =~ /darwin|hpux/i
+  if CONFIG['host_os'] =~ /hpux/i
     Dir.chdir(dir) do
       ruby 'extconf.rb'
       sh 'make'
@@ -63,7 +60,7 @@ task :install => [:build] do
     when /freebsd/i
       file = 'lib/freebsd/sys/proctable.rb'
     when /darwin/i
-      Dir.chdir('ext/darwin'){ sh 'make install' }
+      file = 'lib/darwin/sys/proctable.rb'
     when /hpux/i
       Dir.chdir('ext/hpux'){ sh 'make install' }
   end
@@ -74,7 +71,7 @@ end
 desc 'Uninstall the sys-proctable library'
 task :uninstall do
   case CONFIG['host_os']
-    when /darwin|hpux/i
+    when /hpux/i
       dir  = File.join(CONFIG['sitearchdir'], 'sys')
       file = File.join(dir, 'proctable.' + CONFIG['DLEXT'])
     else
@@ -117,7 +114,7 @@ Rake::TestTask.new do |t|
       t.test_files = FileList['test/test_sys_proctable_freebsd.rb']  
       t.libs << 'lib/freebsd'
     when /darwin/i
-      t.libs << 'ext/darwin'
+      t.libs << 'lib/darwin'
       t.test_files = FileList['test/test_sys_proctable_darwin.rb']
     when /hpux/i
       t.libs << 'ext/hpux'
@@ -153,10 +150,10 @@ namespace :gem do
          spec.add_dependency('ffi')
       when /darwin/i
          spec.platform = Gem::Platform.new(['universal', 'darwin'])
-         spec.files << 'ext/darwin/sys/proctable.c'
-         spec.extra_rdoc_files << 'ext/darwin/sys/proctable.c'
+         spec.require_paths = ['lib', 'lib/darwin']
+         spec.files += ['lib/darwin/sys/proctable.rb']
          spec.test_files << 'test/test_sys_proctable_darwin.rb'
-         spec.extensions = ['ext/darwin/extconf.rb']
+         spec.add_dependency('ffi')
       when /hpux/i
          spec.platform = Gem::Platform.new(['universal', 'hpux'])
          spec.files << 'ext/hpux/sys/proctable.c'

data/lib/darwin/sys/proctable.rb

@@ -0,0 +1,241 @@
+require 'sys/proctable/version'
+require 'ffi'
+
+module Sys
+  class ProcTable
+    extend FFI::Library
+
+    # Error typically raised if the ProcTable.ps method fails.
+    class Error < StandardError; end
+
+    # There is no constructor
+    private_class_method :new
+
+    private
+
+    PROC_ALL_PIDS       = 1
+    PROC_PIDTASKALLINFO = 2
+    PROC_PIDTASKINFO    = 4
+
+    CTL_KERN       = 1
+    KERN_PROCARGS  = 38
+    KERN_PROCARGS2 = 49
+    MAXCOMLEN      = 16
+    MAXPATHLEN     = 256
+
+    PROC_PIDPATHINFO_MAXSIZE = MAXPATHLEN * 4
+
+    class ProcBsdInfo < FFI::Struct
+      layout(
+        :pbi_flags, :uint32_t,
+        :pbi_status, :uint32_t,
+        :pbi_xstatus, :uint32_t,
+        :pbi_pid, :uint32_t,
+        :pbi_ppid, :uint32_t,
+        :pbi_uid, :uid_t,
+        :pbi_gid, :uid_t,
+        :pbi_ruid, :uid_t,
+        :pbi_rgid, :gid_t,
+        :pbi_svuid, :uid_t,
+        :pbi_svgid, :gid_t,
+        :rfu1, :uint32_t,
+        :pbi_comm, [:char, MAXCOMLEN],
+        :pbi_name, [:char, MAXCOMLEN * 2],
+        :pbi_nfiles, :uint32_t,
+        :pbi_pgid, :uint32_t,
+        :pbi_pjobc, :uint32_t,
+        :e_tdev, :uint32_t,
+        :e_tpgid, :uint32_t,
+        :pbi_nice, :int32_t,
+        :pbi_start_tvsec, :uint64_t,
+        :pbi_start_tvusec, :uint64_t
+      )
+    end
+
+    class ProcTaskInfo < FFI::Struct
+      layout(
+        :pti_virtual_size, :uint64_t,
+        :pti_resident_size, :uint64_t,
+        :pti_total_user, :uint64_t,
+        :pti_total_system, :uint64_t,
+        :pti_threads_user, :uint64_t,
+        :pti_threads_system, :uint64_t,
+        :pti_policy, :int32_t,
+        :pti_faults, :int32_t,
+        :pti_pageins, :int32_t,
+        :pti_cow_faults, :int32_t,
+        :pti_messages_sent, :int32_t,
+        :pti_messages_received, :int32_t,
+        :pti_syscalls_mach, :int32_t,
+        :pti_syscalls_unix, :int32_t,
+        :pti_csw, :int32_t,
+        :pti_threadnum, :int32_t,
+        :pti_numrunning, :int32_t,
+        :pti_priority, :int32_t
+      )
+    end
+
+    class ProcTaskAllInfo < FFI::Struct
+      layout(:pbsd, ProcBsdInfo, :ptinfo, ProcTaskInfo)
+    end
+
+    ffi_lib 'proc'
+
+    attach_function :proc_listallpids, [:pointer, :int], :int
+    attach_function :proc_pidinfo, [:int, :int, :uint64_t, :pointer, :int], :int
+
+    ffi_lib FFI::Library::LIBC
+
+    attach_function :sysctl, [:pointer, :uint, :pointer, :pointer, :pointer, :size_t], :int
+
+    # These mostly mimic the struct members, but we've added a few custom ones as well.
+    @fields = %w[
+      flags status xstatus pid ppid uid gid ruid rgid svuid svgid rfu1 comm
+      name nfiles pgid pjobc tdev tpgid nice start_tvsec start_tvusec
+      virtual_size resident_size total_user total_system threads_user
+      threads_system policy faults pageins cow_faults messages_sent
+      messages_received syscalls_mach syscalls_unix csw threadnum numrunning
+      priority cmdline exe environ
+    ]
+
+    # Add a couple aliases to make it similar to Linux
+    ProcTableStruct = Struct.new("ProcTableStruct", *@fields) do
+      alias vsize virtual_size
+      alias rss resident_size
+    end
+
+    public
+
+    # 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
+    # without having to perform at least one read of the process table.
+    #
+    # Example:
+    #
+    #   Sys::ProcTable.fields.each{ |field|
+    #      puts "Field: #{field}"
+    #   }
+    #
+    def self.fields
+      @fields
+    end
+
+    # 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.
+    #
+    # If a +pid+ is provided, then only a single ProcTableStruct is yielded or
+    # returned, or nil if no process information is found for that +pid+.
+    #
+    # Example:
+    #
+    #   # Iterate over all processes
+    #   ProcTable.ps do |proc_info|
+    #      p proc_info
+    #   end
+    #
+    #   # Print process table information for only pid 1001
+    #   p ProcTable.ps(1001)
+    #
+    def self.ps(pid = nil)
+      raise TypeError unless pid.is_a?(Fixnum) if pid
+
+      num = proc_listallpids(nil, 0)
+      ptr = FFI::MemoryPointer.new(:pid_t, num)
+      num = proc_listallpids(ptr, ptr.size)
+
+      raise SystemCallError.new('proc_listallpids', FFI.errno) if num == 0
+
+      pids  = ptr.get_array_of_int32(0, num).sort
+      array = block_given? ? nil : []
+
+      pids.each do |lpid|
+        next unless pid == lpid if pid
+        info = ProcTaskAllInfo.new
+
+        if proc_pidinfo(lpid, PROC_PIDTASKALLINFO, 0, info, info.size) <= 0
+          if [Errno::EPERM::Errno, Errno::ESRCH::Errno].include?(FFI.errno)
+            next # Either we don't have permission, or the pid no longer exists
+          else
+            raise SystemCallError.new('proc_pidinfo', FFI.errno)
+          end
+        end
+
+        struct = ProcTableStruct.new
+        get_cmd_args_and_env(lpid, struct) # Pass by reference
+
+        # Chop the leading xx_ from the FFI struct members for our ruby struct.
+        info.members.each do |nested|
+          info[nested].members.each do |member|
+            temp = member.to_s.split('_')
+            sproperty = temp.size > 1 ? temp[1..-1].join('_') : temp.first
+            if info[nested][member].is_a?(FFI::StructLayout::CharArray)
+              struct[sproperty.to_sym] = info[nested][member].to_s
+            else
+              struct[sproperty.to_sym] = info[nested][member]
+            end
+          end
+        end
+
+        struct.freeze
+
+        if block_given?
+          yield struct
+        else
+          array << struct
+        end
+      end
+
+      return nil if array.nil?
+      pid ? array.first : array
+    end
+
+    private
+
+    # Get the command line arguments, as well as the environment settings,
+    # for the given PID.
+    #
+    def self.get_cmd_args_and_env(pid, struct)
+      len = FFI::MemoryPointer.new(:size_t)
+      mib = FFI::MemoryPointer.new(:int, 3)
+
+      # Since we may not have access to the process information due
+      # to improper privileges, just bail if we see a failure here.
+
+      mib.write_array_of_int([CTL_KERN, KERN_PROCARGS, pid])
+      return if sysctl(mib, 3, nil, len, nil, 0) < 0
+
+      buf = FFI::MemoryPointer.new(:char, len.read_ulong)
+      return if sysctl(mib, 3, buf, len, nil, 0) < 0
+
+      exe = buf.read_string # Read up to first null, does not include args
+      struct[:exe] = exe
+
+      # Parse the rest of the information out of big, ugly sring
+      array = buf.read_bytes(len.read_ulong).split(0.chr)
+      array.shift      # Delete first exe
+      array.delete('') # Delete empty strings
+
+      cmdline = ''
+
+      # Anything that doesn't include a '=' sign is a cmdline argument.
+      while array[0] && !array[0].include?('=')
+        cmdline << ' ' + array.shift
+      end
+
+      struct[:cmdline] = File.basename(cmdline.strip)
+
+      # Anything remaining at this point is a collect of key=value pairs which
+      # we convert into a hash.
+      environ = array.inject({}) do |hash, string|
+        if string && string.include?('=')
+          key, value = string.split('=')
+          hash[key] = value
+        end
+        hash
+      end
+
+      struct[:environ] = environ
+    end
+  end
+end

data/lib/sys/proctable/version.rb

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

data/sys-proctable.gemspec

@@ -2,9 +2,9 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'sys-proctable'
-  spec.version    = '1.0.0'
+  spec.version    = '1.1.0'
   spec.author     = 'Daniel J. Berger'
-  spec.license    = 'Artistic 2.0' 
+  spec.license    = 'Apache 2.0'
   spec.email      = 'djberg96@gmail.com'
   spec.homepage   = 'http://github.com/djberg96/sys-proctable'
   spec.platform   = Gem::Platform::CURRENT # Probably altered by Rake task

data/test/test_sys_proctable_all.rb

@@ -15,66 +15,77 @@ class TC_ProcTable_All < Test::Unit::TestCase
   end
 
   def setup
-    @pid = @@windows ? 0 : 1
+    @pid = Process.pid
   end
 
-  def test_version
-    assert_equal('1.0.0', ProcTable::VERSION)
+  test "version is set to expected value" do
+    assert_equal('1.1.0', ProcTable::VERSION)
   end
 
-  def test_fields
+  test "fields basic functionality" do
     assert_respond_to(ProcTable, :fields)
     assert_nothing_raised{ ProcTable.fields }
+  end
+
+  test "fields returns expected type" do
     assert_kind_of(Array, ProcTable.fields)
     assert_kind_of(String, ProcTable.fields.first)
   end
 
-  def test_ps
+  test "ps basic functionality" do
     assert_respond_to(ProcTable, :ps)
     assert_nothing_raised{ ProcTable.ps }
     assert_nothing_raised{ ProcTable.ps{} }
   end
 
-  def test_ps_with_pid
+  test "ps accepts an optional pid" do
     assert_nothing_raised{ ProcTable.ps(0) }
   end
 
-  def test_ps_with_explicit_nil
+  test "ps with explicit nil works as expected" do
     assert_nothing_raised{ ProcTable.ps(nil) }
     assert_kind_of(Array, ProcTable.ps(nil))
   end
 
-  def test_ps_return_value
+  test "ps returns expected results" do
     assert_kind_of(Array, ProcTable.ps)
     assert_kind_of(Struct::ProcTableStruct, ProcTable.ps(@pid))
-    assert_equal(nil, ProcTable.ps(999999999))
-    assert_equal(nil, ProcTable.ps(999999999){})
-    assert_equal(nil, ProcTable.ps{})
   end
 
-  def test_ps_returned_struct_is_frozen
+  test "ps returns nil if process does not exist" do
+    assert_nil(ProcTable.ps(999999999))
+    assert_nil(ProcTable.ps(999999999){})
+    assert_nil(ProcTable.ps{})
+  end
+
+  test "structs returned by ps are frozen" do
     assert_true(ProcTable.ps.first.frozen?)
   end
 
-  def test_ps_expected_errors
+  test "ps accepts numeric arguments only" do
     assert_raises(TypeError){ ProcTable.ps('vim') }
+  end
+
+  test "ps accepts a maximum of one argument on Unix platforms" do
     omit_if(@@windows, 'ArgumentError check skipped on MS Windows')
     assert_raises(ArgumentError){ ProcTable.ps(0, 'localhost') }
   end
 
-  def test_new_not_allowed
+  test "traditional constructor is disabled" do
     assert_raise(NoMethodError){ Sys::ProcTable.new }
   end
 
-  def test_error_class_defined
+  test "custom error class is defined" do
     assert_not_nil(Sys::ProcTable::Error)
     assert_kind_of(StandardError, Sys::ProcTable::Error.new)
   end
 
-  def test_from_thread
-    Thread.new do
-      Sys::ProcTable.ps
-    end.value
+  test "ps works within a thread" do
+    assert_nothing_raised{
+      Thread.new do
+        Sys::ProcTable.ps
+      end.value
+    }
   end
 
   def teardown