sys-proctable 0.9.3-universal-freebsd → 0.9.4-universal-freebsd

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c45e6ae56c6571febf5b2b7038bcc643d3cb337
+  data.tar.gz: f42dd07643ccc87be3ad289b8b0e9d3b2c7252cf
+SHA512:
+  metadata.gz: 06e5a4dfbe1c74ca7fae99ceaad63adf7657fb789298fb7928f776c5684611b82927cca7b3abc4b1671771ea1383953c3f4ad91bcfb7a69cc8f2236612c6c46f
+  data.tar.gz: 87253dd8de985d402bc83034083c603743e4ae6ac80121a4c6b5bdfb1b58d4c0ae483071fa60205b9038887b0425ed6fe06289b2af4ce85ec49e94314f40d3cb

data/CHANGES

@@ -1,3 +1,14 @@
+== 0.9.4 - 4-Mar-2014
+* Added support for AIX 5.3 or later courtesy of Rick Ohnemus.
+* The Solaris version now uses FFI structs instead of a packed array.
+  It solved issues with 64-bit versions of Ruby and it's self-documenting.
+* The FreeBSD version has been converted to use FFI. In addition, additional
+  struct members have been added, and members that previously returned nil
+  now return meaningful data.
+* Support for NetBSD and OpenBSD has been temporarily dropped. Considering
+  that the C code did not build on those platforms anyway, I doubt most of
+  you will notice. Patches for those platforms are welcome, but only using FFI.
+
 == 0.9.3 - 17-Mar-2013
 * Fixed a bug on OSX where a long command string arg could cause
   a segfault. Thanks go to Nathaniel Bibler for the spot.

data/MANIFEST

@@ -3,6 +3,7 @@
 * Rakefile
 * README
 * sys-proctable.gemspec
+* doc/aix.txt
 * doc/bsd.txt
 * doc/hpux.txt
 * doc/linux.txt
@@ -10,20 +11,21 @@
 * doc/top.txt
 * doc/windows.txt
 * example/example_ps.rb
-* ext/bsd/extconf.rb
-* ext/bsd/sys/proctable.c
 * ext/darwin/extconf.rb
 * ext/darwin/sys/proctable.c
 * ext/hpux/extconf.rb
 * ext/hpux/sys/proctable.c
 * lib/sys/top.rb
+* lib/aix/sys/proctable.rb
+* lib/freebsd/sys/proctable.rb
 * lib/linux/sys/proctable.rb
 * lib/sunos/sys/proctable.rb
 * lib/windows/sys/proctable.rb
+* test/test_sys_proctable_aix.rb
 * test/test_sys_proctable_all.rb
 * test/test_sys_proctable_darwin.rb
+* test/test_sys_proctable_freebsd.rb
 * test/test_sys_proctable_hpux.rb
-* test/test_sys_proctable_bsd.rb
 * test/test_sys_proctable_linux.rb
 * test/test_sys_proctable_sunos.rb
 * test/test_sys_proctable_windows.rb

data/README

@@ -7,7 +7,7 @@
 == Supported Platforms
 * Windows 2000 or later
 * Linux 2.6+
-* BSD (various flavors)
+* FreeBSD
 * Solaris 8+
 * HP-UX 10+
 * OS X 10.4+
@@ -20,7 +20,7 @@
   gem install sys-proctable --platform mswin32 # Windows
   gem install sys-proctable --platform sunos   # Solaris
   gem install sys-proctable --platform linux   # Linux
-  gem install sys-proctable --platform freebsd # BSD (any flavor)
+  gem install sys-proctable --platform freebsd # FreeBSD
 
 == Synopsis
   require 'sys/proctable'
@@ -51,7 +51,7 @@
   information from a different host. This relies on the WMI service running.
 
 == Known Issues
-=== BSD
+=== FreeBSD
   A kvm interface is used. That means the owner of the process using the
   sys-proctable library needs to be a member of the kvm group (or root).
 
@@ -67,13 +67,12 @@
   Using readdir_r() still won't solve all potential thread safety issues anyway.
 
 == Future Plans
-  Research has indicated that the kvm approach is less favored than a sysctl
-  approach on BSD variants. I will try to add this interface in a future
-  release.
+  Add support for NetBSD and OpenBSD.
+  Convert existing C code to FFI.
 
 == Acknowledgements
-  This library is largely based on the Perl module Proc::ProcessTable by
-  Dan Urist. Many ideas, as well as large chunks of code, were taken
+  This library was originally based on the Perl module Proc::ProcessTable
+  by Dan Urist. Many ideas, as well as large chunks of code, were taken
   from his work. So, a big THANK YOU goes out to Dan Urist.
 
   A big thanks also goes out to Mike Hall who was very helpful with ideas,
@@ -105,7 +104,7 @@
   Artistic 2.0
     
 == Copyright
-  (C) 2003-2012 Daniel J. Berger
+  (C) 2003-2014 Daniel J. Berger
   All Rights Reserved.
 
 == Author

data/Rakefile

@@ -8,7 +8,7 @@ CLEAN.include(
   '**/*.core',              # Core dump files
   '**/*.gem',               # Gem files
   '**/*.rbc',               # Rubinius
-  '.rbx', '**/*/.rbx',      # Rubinius
+  '**/*.rbx',               # Rubinius
   '**/*.o',                 # C object file
   '**/*.log',               # Ruby extension build log
   '**/Makefile',            # C Makefile
@@ -27,9 +27,6 @@ task :build => [:clean] do
   end
 
   case CONFIG['host_os']
-    when /bsd/i
-      dir = 'ext/bsd'
-      ext = '.so'
     when /darwin/i
       dir = 'ext/darwin'
       ext = '.bundle'
@@ -38,7 +35,7 @@ task :build => [:clean] do
       ext = '.sl'
   end
 
-  unless CONFIG['host_os'] =~ /win32|mswin|dos|cygwin|mingw|windows|linux|sunos|solaris/i
+  if CONFIG['host_os'] =~ /darwin|hpux/i
     Dir.chdir(dir) do
       ruby 'extconf.rb'
       sh 'make'
@@ -61,8 +58,10 @@ task :install => [:build] do
       file = 'lib/linux/sys/proctable.rb'
     when /sunos|solaris/i
       file = 'lib/sunos/sys/proctable.rb'
-    when /bsd/i
-      Dir.chdir('ext/bsd'){ sh 'make install' }
+    when /aix/i
+      file = 'lib/aix/sys/proctable.rb'
+    when /freebsd/i
+      file = 'lib/freebsd/sys/proctable.rb'
     when /darwin/i
       Dir.chdir('ext/darwin'){ sh 'make install' }
     when /hpux/i
@@ -75,12 +74,12 @@ end
 desc 'Uninstall the sys-proctable library'
 task :uninstall do
   case CONFIG['host_os']
-    when /win32|mswin|dos|cygwin|mingw|windows|linux|sunos|solaris/i
-      dir  = File.join(CONFIG['sitelibdir'], 'sys')
-      file = File.join(dir, 'proctable.rb')
-    else
+    when /darwin|hpux/i
       dir  = File.join(CONFIG['sitearchdir'], 'sys')
       file = File.join(dir, 'proctable.' + CONFIG['DLEXT'])
+    else
+      dir  = File.join(CONFIG['sitelibdir'], 'sys')
+      file = File.join(dir, 'proctable.rb')
   end
 
   rm(file) 
@@ -111,12 +110,15 @@ Rake::TestTask.new do |t|
     when /sunos|solaris/i
       t.test_files = FileList['test/test_sys_proctable_sunos.rb']
       t.libs << 'lib/sunos'
+    when /aix/i
+      t.test_files = FileList['test/test_sys_proctable_aix.rb']
+      t.libs << 'lib/aix'
+    when /freebsd/i
+      t.test_files = FileList['test/test_sys_proctable_freebsd.rb']  
+      t.libs << 'lib/freebsd'
     when /darwin/i
       t.libs << 'ext/darwin'
       t.test_files = FileList['test/test_sys_proctable_darwin.rb']
-    when /bsd/i
-      t.libs << 'ext/bsd'
-      t.test_files = FileList['test/test_sys_proctable_bsd.rb']  
     when /hpux/i
       t.libs << 'ext/hpux'
       t.test_files = FileList['test/test_sys_proctable_hpux.rb']  
@@ -133,13 +135,12 @@ namespace :gem do
     # of some bugginess in Rubygems' platform.rb.
     #
     case CONFIG['host_os']
-      when /bsd/i
+      when /freebsd/i
          spec.platform = Gem::Platform.new(['universal', 'freebsd'])
-         spec.platform.version = nil
-         spec.files << 'ext/bsd/sys/proctable.c'
-         spec.extra_rdoc_files << 'ext/bsd/sys/proctable.c'
-         spec.test_files << 'test/test_sys_proctable_bsd.rb'
-         spec.extensions = ['ext/bsd/extconf.rb']
+         spec.require_paths = ['lib', 'lib/freebsd']
+         spec.files += ['lib/freebsd/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_freebsd.rb'
+         spec.add_dependency('ffi')
       when /darwin/i
          spec.platform = Gem::Platform.new(['universal', 'darwin'])
          spec.files << 'ext/darwin/sys/proctable.c'
@@ -162,6 +163,11 @@ namespace :gem do
          spec.require_paths = ['lib', 'lib/sunos']
          spec.files += ['lib/sunos/sys/proctable.rb']
          spec.test_files << 'test/test_sys_proctable_sunos.rb'
+      when /aix/i
+         spec.platform = Gem::Platform.new(['universal', 'aix5'])
+         spec.require_paths = ['lib', 'lib/aix']
+         spec.files += ['lib/aix/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_aix.rb'
       when /mswin|win32|dos|cygwin|mingw|windows/i
          spec.platform = Gem::Platform.new(['universal', 'mingw32'])
          spec.require_paths = ['lib', 'lib/windows']
@@ -172,7 +178,12 @@ namespace :gem do
     # https://github.com/rubygems/rubygems/issues/147
     spec.original_platform = spec.platform
 
-    Gem::Builder.new(spec).build
+    if Gem::VERSION < "2.0"
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
   end
 
   desc 'Install the sys-proctable library as a gem'

data/lib/freebsd/sys/proctable.rb

@@ -0,0 +1,363 @@
+require 'ffi'
+
+module Sys
+  class ProcTable
+    extend FFI::Library
+
+    # The version of the sys-proctable library.
+    VERSION = '0.9.4'
+
+    # Error typically raised if the ProcTable.ps method fails.
+    class Error < StandardError; end
+
+    # There is no constructor
+    private_class_method :new
+
+    private
+
+    ffi_lib :kvm
+
+    attach_function :devname, [:dev_t, :mode_t], :string
+    attach_function :kvm_open, [:string, :string, :string, :int, :string], :pointer
+    attach_function :kvm_close, [:pointer], :int
+    attach_function :kvm_getprocs, [:pointer, :int, :int, :pointer], :pointer
+    attach_function :kvm_getargv, [:pointer, :pointer, :int], :pointer
+
+    POSIX_ARG_MAX = 4096
+
+    KERN_PROC_PID  = 1
+    KERN_PROC_PROC = 8
+
+    S_IFCHR = 0020000
+
+    WMESGLEN       = 8
+    LOCKNAMELEN    = 8
+    OCOMMLEN       = 16
+    COMMLEN        = 19
+    KI_EMULNAMELEN = 16
+    KI_NGROUPS     = 16
+    LOGNAMELEN     = 17
+    KI_NSPARE_INT  = 9
+    KI_NSPARE_LONG = 12
+    KI_NSPARE_PTR  = 6
+
+    class Timeval < FFI::Struct
+      layout(:tv_sec, :time_t, :tv_usec, :suseconds_t)
+    end
+
+    class Priority < FFI::Struct
+      layout(
+        :pri_class, :uchar,
+        :pri_level, :uchar,
+        :pri_native, :uchar,
+        :pri_user, :uchar
+      )
+    end
+
+    class Rusage < FFI::Struct
+      layout(
+        :ru_utime, Timeval,
+        :ru_stime, Timeval,
+        :ru_maxrss, :long,
+        :ru_ixrss, :long,
+        :ru_idrss, :long,
+        :ru_isrss, :long,
+        :ru_minflt, :long,
+        :ru_majflt, :long,
+        :ru_nswap, :long,
+        :ru_inblock, :long,
+        :ru_oublock, :long,
+        :ru_msgsnd, :long,
+        :ru_msgrcv, :long,
+        :ru_nsignals, :long,
+        :ru_nvcsw, :long,
+        :ru_nivcsw, :long
+      )
+    end
+
+    class Pargs < FFI::Struct
+      layout(
+        :ar_ref, :uint,
+        :ar_length, :uint,
+        :ar_args, [:uchar,1]
+      )
+    end
+
+    class KInfoProc < FFI::Struct
+      layout(
+        :ki_structsize, :int,
+        :ki_layout, :int,
+        :ki_args, :pointer,
+        :ki_paddr, :pointer,
+        :ki_addr, :pointer,
+        :ki_tracep, :pointer,
+        :ki_textvp, :pointer,
+        :ki_fd, :pointer,
+        :ki_vmspace, :pointer,
+        :ki_wchan, :pointer,
+        :ki_pid, :pid_t,
+        :ki_ppid, :pid_t,
+        :ki_pgid, :pid_t,
+        :ki_tpgid, :pid_t,
+        :ki_sid, :pid_t,
+        :ki_tsid, :pid_t,
+        :ki_jobc, :short,
+        :ki_spare_short1, :short,
+        :ki_tdev, :dev_t,
+        :ki_siglist, [:uint32_t, 4],
+        :ki_sigmask, [:uint32_t, 4],
+        :ki_sigignore, [:uint32_t, 4],
+        :ki_sigcatch, [:uint32_t, 4],
+        :ki_uid, :uid_t,
+        :ki_ruid, :uid_t,
+        :ki_svuid, :uid_t,
+        :ki_rgid, :gid_t,
+        :ki_svgid, :gid_t,
+        :ki_ngroups, :short,
+        :ki_spare_short2, :short,
+        :ki_groups, [:gid_t, KI_NGROUPS],
+        :ki_size, :vm_size_t,
+        :ki_rssize, :segsz_t,
+        :ki_swrss, :segsz_t,
+        :ki_tsize, :segsz_t,
+        :ki_dsize, :segsz_t,
+        :ki_ssize, :segsz_t,
+        :ki_xstat, :u_short,
+        :ki_acflag, :u_short,
+        :ki_pctcpu, :fixpt_t,
+        :ki_estcpu, :uint,
+        :ki_slptime, :uint,
+        :ki_swtime, :uint,
+        :ki_swtime, :int,
+        :ki_runtime, :uint64_t,
+        :ki_start, Timeval,
+        :ki_childtime, Timeval,
+        :ki_flag, :long,
+        :ki_kiflag, :long,
+        :ki_traceflag, :int,
+        :ki_stat, :char,
+        :ki_nice, :char,
+        :ki_lock, :char,
+        :ki_rqindex, :char,
+        :ki_oncpu, :uchar,
+        :ki_lastcpu, :uchar,
+        :ki_ocomm, [:char, OCOMMLEN+1],
+        :ki_wmesg, [:char, WMESGLEN+1],
+        :ki_login, [:char, LOGNAMELEN+1],
+        :ki_lockname, [:char, LOCKNAMELEN+1],
+        :ki_comm, [:char, COMMLEN+1],
+        :ki_emul, [:char, KI_EMULNAMELEN+1],
+        :ki_sparestrings, [:char, 68],
+        :ki_spareints, [:int, KI_NSPARE_INT],
+        :ki_cr_flags, :uint,
+        :ki_jid, :int,
+        :ki_numthreads, :int,
+        :ki_tid, :lwpid_t,
+        :ki_pri, Priority,
+        :ki_rusage, Rusage,
+        :ki_rusage_ch, Rusage,
+        :ki_pcb, :pointer,
+        :ki_kstack, :pointer,
+        :ki_udata, :pointer,
+        :ki_tdaddr, :pointer,
+        :ki_spareptrs, [:pointer, KI_NSPARE_PTR],
+        :ki_sparelongs, [:long, KI_NSPARE_LONG],
+        :ki_sflags, :long,
+        :ki_tdflags, :long
+      )
+    end
+
+    @fields = %w[
+      pid ppid pgid tpgid sid tsid jobc uid ruid rgid
+      ngroups groups size rssize swrss tsize dsize ssize
+      xstat acflag pctcpu estcpu slptime swtime runtime start
+      flag state nice lock rqindex oncpu lastcpu wmesg login
+      lockname comm ttynum ttydev jid priority usrpri cmdline
+      utime stime maxrss ixrss idrss isrss minflt majflt nswap
+      inblock oublock msgsnd msgrcv nsignals nvcsw nivcsw
+    ]
+
+    ProcTableStruct = Struct.new('ProcTableStruct', *@fields)
+
+    public
+
+    # 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)
+      begin
+        kd = kvm_open(nil, nil, nil, 0, nil)
+
+        if kd.null?
+          raise SystemCallError.new('kvm_open', FFI.errno)
+        end
+
+        ptr = FFI::MemoryPointer.new(:int) # count
+
+        if pid
+          procs = kvm_getprocs(kd, KERN_PROC_PID, pid, ptr)
+        else
+          procs = kvm_getprocs(kd, KERN_PROC_PROC, 0, ptr)
+        end
+
+        if procs.null?
+          if pid && FFI.errno == Errno::ESRCH::Errno
+            return nil
+          else
+            raise SystemCallError.new('kvm_getprocs', FFI.errno)
+          end
+        end
+
+        count = ptr.read_int
+        array = []
+
+        0.upto(count-1){ |i|
+          cmd = nil
+          kinfo = KInfoProc.new(procs[i * KInfoProc.size])
+
+          args = kvm_getargv(kd, kinfo, 0)
+
+          unless args.null?
+            cmd = []
+
+            until ((ptr = args.read_pointer).null?)
+              cmd << ptr.read_string
+              args += FFI::Type::POINTER.size
+            end
+
+            cmd = cmd.join(' ')
+          end
+
+          struct = ProcTableStruct.new(
+            kinfo[:ki_pid],
+            kinfo[:ki_ppid],
+            kinfo[:ki_pgid],
+            kinfo[:ki_tpgid],
+            kinfo[:ki_sid],
+            kinfo[:ki_tsid],
+            kinfo[:ki_jobc],
+            kinfo[:ki_uid],
+            kinfo[:ki_ruid],
+            kinfo[:ki_rgid],
+            kinfo[:ki_ngroups],
+            kinfo[:ki_groups].to_a[0...kinfo[:ki_ngroups]],
+            kinfo[:ki_size],
+            kinfo[:ki_rssize],
+            kinfo[:ki_swrss],
+            kinfo[:ki_tsize],
+            kinfo[:ki_dsize],
+            kinfo[:ki_ssize],
+            kinfo[:ki_xstat],
+            kinfo[:ki_acflag],
+            kinfo[:ki_pctcpu].to_f,
+            kinfo[:ki_estcpu],
+            kinfo[:ki_slptime],
+            kinfo[:ki_swtime],
+            kinfo[:ki_runtime],
+            Time.at(kinfo[:ki_start][:tv_sec]),
+            kinfo[:ki_flag],
+            get_state(kinfo[:ki_stat]),
+            kinfo[:ki_nice],
+            kinfo[:ki_lock],
+            kinfo[:ki_rqindex],
+            kinfo[:ki_oncpu],
+            kinfo[:ki_lastcpu],
+            kinfo[:ki_wmesg].to_s,
+            kinfo[:ki_login].to_s,
+            kinfo[:ki_lockname].to_s,
+            kinfo[:ki_comm].to_s,
+            kinfo[:ki_tdev],
+            devname(kinfo[:ki_tdev], S_IFCHR),
+            kinfo[:ki_jid],
+            kinfo[:ki_pri][:pri_level],
+            kinfo[:ki_pri][:pri_user],
+            cmd,
+            kinfo[:ki_rusage][:ru_utime][:tv_sec],
+            kinfo[:ki_rusage][:ru_stime][:tv_sec],
+            kinfo[:ki_rusage][:ru_maxrss],
+            kinfo[:ki_rusage][:ru_ixrss],
+            kinfo[:ki_rusage][:ru_idrss],
+            kinfo[:ki_rusage][:ru_isrss],
+            kinfo[:ki_rusage][:ru_minflt],
+            kinfo[:ki_rusage][:ru_majflt],
+            kinfo[:ki_rusage][:ru_nswap],
+            kinfo[:ki_rusage][:ru_inblock],
+            kinfo[:ki_rusage][:ru_oublock],
+            kinfo[:ki_rusage][:ru_msgsnd],
+            kinfo[:ki_rusage][:ru_msgrcv],
+            kinfo[:ki_rusage][:ru_nsignals],
+            kinfo[:ki_rusage][:ru_nvcsw],
+            kinfo[:ki_rusage][:ru_nivcsw]
+          )
+
+          struct.freeze # This is readonly data
+
+          if block_given?
+            yield struct
+          else
+            array << struct
+          end
+        }
+      ensure
+        kvm_close(kd) unless kd.null?
+      end
+
+      if block_given?
+        nil
+      else
+        pid ? array.first : array
+      end
+    end
+
+    # 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 /proc table.
+    #
+    # Example:
+    #
+    #   Sys::ProcTable.fields.each{ |field|
+    #      puts "Field: #{field}"
+    #   }
+    #
+    def self.fields
+      @fields
+    end
+
+    private
+
+    SIDL   = 1
+    SRUN   = 2
+    SSLEEP = 3
+    SSTOP  = 4
+    SZOMB  = 5
+    SWAIT  = 6
+    SLOCK  = 7
+
+    def self.get_state(int)
+      case int
+        when SIDL; "idle"
+        when SRUN; "run"
+        when SSLEEP; "sleep"
+        when SSTOP; "stop"
+        when SZOMB; "zombie"
+        when SWAIT; "waiting"
+        when SLOCK; "locked"
+        else; "unknown"
+      end
+    end
+  end
+end

data/lib/sys/top.rb

@@ -7,19 +7,21 @@ module Sys
   class Top
 
     # The version of the sys-top library
-    VERSION = '1.0.3'
+    VERSION = '1.0.4'
 
     # Returns an array of Struct::ProcTableStruct elements containing up
     # to +num+ elements, sorted by +field+. The default number of elements
     # is 10, while the default field is 'pctcpu'.
     #
-    # Exception: the default sort field is 'pid' on Linux and Windows.
+    # Exception: the default sort field is 'pid' on AIX and Windows.
     #
     def self.top(num=10, field='pctcpu')
       field = field.to_s if field.is_a?(Symbol)
 
-      # Sort by pid on Windows by default
-      if File::ALT_SEPARATOR && field == 'pctcpu'
+      aix = RbConfig::CONFIG['host_os'] =~ /aix/i
+
+      # Sort by pid on Windows and AIX by default
+      if (File::ALT_SEPARATOR || aix) && field == 'pctcpu'
         field = 'pid'
       end
 

data/sys-proctable.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'sys-proctable'
-  spec.version    = '0.9.3'
+  spec.version    = '0.9.4'
   spec.author     = 'Daniel J. Berger'
   spec.license    = 'Artistic 2.0' 
   spec.email      = 'djberg96@gmail.com'
@@ -26,7 +26,8 @@ Gem::Specification.new do |spec|
   spec.rubyforge_project = 'sysutils'
   spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST', 'doc/top.txt']
 
-  spec.add_development_dependency('test-unit', '>= 2.4.0')
+  spec.add_development_dependency('test-unit')
+  spec.add_development_dependency('rake')
 
   spec.description = <<-EOF
     The sys-proctable library provides an interface for gathering information

data/test/test_sys_proctable_all.rb

@@ -4,10 +4,7 @@
 # Test suite for methods common to all platforms. Generally speaking
 # you should run this test case using the 'rake test' task.
 #######################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
+require 'test-unit'
 require 'sys/proctable'
 require 'test/test_sys_top'
 include Sys
@@ -22,7 +19,7 @@ class TC_ProcTable_All < Test::Unit::TestCase
   end
 
   def test_version
-    assert_equal('0.9.3', ProcTable::VERSION)
+    assert_equal('0.9.4', ProcTable::VERSION)
   end
 
   def test_fields

data/test/{test_sys_proctable_bsd.rb → test_sys_proctable_freebsd.rb}

@@ -1,29 +1,29 @@
 ################################################################
-# test_sys_proctable_bsd.rb
+# test_sys_proctable_freebsd.rb
 #
-# Test suite for various BSD flavors for the sys-proctable
-# library. You should run these tests via 'rake test'.
+# Test suite for FreeBSD for the sys-proctable library.
+# You should run these tests via 'rake test'.
 ################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
+require 'test-unit'
 require 'sys/proctable'
 require 'test/test_sys_proctable_all'
 include Sys
 
-class TC_Sys_ProcTable_BSD < Test::Unit::TestCase
+class TC_Sys_ProcTable_FreeBSD < Test::Unit::TestCase
   def self.startup
-    @@fields = %w/
-      pid ppid pgid ruid rgid comm state pctcpu oncpu ttynum ttydev
-      wmesg time priority usrpri nice cmdline start
-      maxrss ixrss idrss isrss minflt majflt nswap inblock oublock
-      msgsnd msgrcv nsignals nvcsw nivcsw utime stime
-    /
+    @@fields = %w[
+      pid ppid pgid tpgid sid tsid jobc uid ruid rgid
+      ngroups groups size rssize swrss tsize dsize ssize
+      xstat acflag pctcpu estcpu slptime swtime runtime start
+      flag state nice lock rqindex oncpu lastcpu wmesg login
+      lockname comm ttynum ttydev jid priority usrpri cmdline
+      utime stime maxrss ixrss idrss isrss minflt majflt nswap
+      inblock oublock msgsnd msgrcv nsignals nvcsw nivcsw
+    ]
   end
 
   def setup
-    @ptable = ProcTable.ps.last
+    @ptable = ProcTable.ps(Process.pid)
   end
 
   def test_fields
@@ -92,9 +92,9 @@ class TC_Sys_ProcTable_BSD < Test::Unit::TestCase
     assert_kind_of(String, @ptable.wmesg)
   end
 
-  def test_time
-    assert_respond_to(@ptable, :time)
-    assert_kind_of(Fixnum, @ptable.time)
+  def test_runtime
+    assert_respond_to(@ptable, :runtime)
+    assert_kind_of(Fixnum, @ptable.runtime)
   end
 
   def test_priority
@@ -124,82 +124,82 @@ class TC_Sys_ProcTable_BSD < Test::Unit::TestCase
 
   def test_maxrss
     assert_respond_to(@ptable, :maxrss)
-    assert_true(@ptable.maxrss.kind_of?(Fixnum) || @ptable.maxrss.nil?)
+    assert_kind_of(Fixnum, @ptable.maxrss)
   end
 
   def test_ixrss
     assert_respond_to(@ptable, :ixrss)
-    assert_true(@ptable.ixrss.kind_of?(Fixnum) || @ptable.ixrss.nil?)
+    assert_kind_of(Fixnum, @ptable.ixrss)
   end
 
   def test_idrss
     assert_respond_to(@ptable, :idrss)
-    assert_true(@ptable.idrss.kind_of?(Fixnum) || @ptable.idrss.nil?)
+    assert_kind_of(Fixnum, @ptable.idrss)
   end
 
   def test_isrss
     assert_respond_to(@ptable, :isrss)
-    assert_true(@ptable.isrss.kind_of?(Fixnum) || @ptable.isrss.nil?)
+    assert_kind_of(Fixnum, @ptable.isrss)
   end
 
   def test_minflt
     assert_respond_to(@ptable, :minflt)
-    assert_true(@ptable.minflt.kind_of?(Fixnum) || @ptable.minflt.nil?)
+    assert_kind_of(Fixnum, @ptable.minflt)
   end
 
   def test_majflt
     assert_respond_to(@ptable, :majflt)
-    assert_true(@ptable.majflt.kind_of?(Fixnum) || @ptable.majflt.nil?)
+    assert_kind_of(Fixnum, @ptable.majflt)
   end
 
   def test_nswap
     assert_respond_to(@ptable, :nswap)
-    assert_true(@ptable.nswap.kind_of?(Fixnum) || @ptable.nswap.nil?)
+    assert_kind_of(Fixnum, @ptable.nswap)
   end
 
   def test_inblock
     assert_respond_to(@ptable, :inblock)
-    assert_true(@ptable.inblock.kind_of?(Fixnum) || @ptable.inblock.nil?)
+    assert_kind_of(Fixnum, @ptable.inblock)
   end
 
   def test_oublock
     assert_respond_to(@ptable, :oublock)
-    assert_true(@ptable.oublock.kind_of?(Fixnum) || @ptable.oublock.nil?)
+    assert_kind_of(Fixnum, @ptable.oublock)
   end
 
   def test_msgsnd
     assert_respond_to(@ptable, :msgsnd)
-    assert_true(@ptable.msgsnd.kind_of?(Fixnum) || @ptable.msgsnd.nil?)
+    assert_kind_of(Fixnum, @ptable.msgsnd)
   end
 
   def test_msgrcv
     assert_respond_to(@ptable, :msgrcv)
-    assert_true(@ptable.msgrcv.kind_of?(Fixnum) || @ptable.msgrcv.nil?)
+    assert_kind_of(Fixnum, @ptable.msgrcv)
   end
 
   def test_nsignals
     assert_respond_to(@ptable, :nsignals)
-    assert_true(@ptable.nsignals.kind_of?(Fixnum) || @ptable.nsignals.nil?)
+    assert_kind_of(Fixnum, @ptable.nsignals)
   end
 
   def test_nvcsw
     assert_respond_to(@ptable, :nvcsw)
-    assert_true(@ptable.nvcsw.kind_of?(Fixnum) || @ptable.nvcsw.nil?)
+    assert_kind_of(Fixnum, @ptable.nvcsw)
   end
 
   def test_nivcsw
     assert_respond_to(@ptable, :nivcsw)
-    assert_true(@ptable.nivcsw.kind_of?(Fixnum) || @ptable.nivcsw.nil?)
+    assert_kind_of(Fixnum, @ptable.nivcsw)
   end
 
   def test_utime
     assert_respond_to(@ptable, :utime)
-    assert_true(@ptable.utime.kind_of?(Fixnum) || @ptable.utime.nil?)
+    assert_kind_of(Fixnum, @ptable.utime)
   end
 
   def test_stime
     assert_respond_to(@ptable, :stime)
-    assert_true(@ptable.stime.kind_of?(Fixnum) || @ptable.stime.nil?)
+    assert_kind_of(Fixnum, @ptable.stime)
   end
 
   def teardown

metadata

@@ -1,97 +1,109 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sys-proctable
-version: !ruby/object:Gem::Version 
-  hash: 61
-  prerelease: 
-  segments: 
-  - 0
-  - 9
-  - 3
-  version: 0.9.3
+version: !ruby/object:Gem::Version
+  version: 0.9.4
 platform: universal-freebsd
-authors: 
+authors:
 - Daniel J. Berger
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-12-08 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 2
-        - 4
-        - 0
-        version: 2.4.0
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-description: "    The sys-proctable library provides an interface for gathering information\n    about processes on your system, i.e. the process table. Most major\n    platforms are supported and, while different platforms may return\n    different information, the external interface is identical across\n    platforms.\n"
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      The sys-proctable library provides an interface for gathering information
+      about processes on your system, i.e. the process table. Most major
+      platforms are supported and, while different platforms may return
+      different information, the external interface is identical across
+      platforms.
 email: djberg96@gmail.com
 executables: []
-
-extensions: 
-- ext/bsd/extconf.rb
-extra_rdoc_files: 
+extensions: []
+extra_rdoc_files:
 - CHANGES
 - README
 - MANIFEST
 - doc/top.txt
-- ext/bsd/sys/proctable.c
-files: 
-- benchmarks/bench_ps.rb
-- examples/example_ps.rb
-- lib/sys/top.rb
+files:
 - CHANGES
 - MANIFEST
-- Rakefile
 - README
+- Rakefile
+- benchmarks/bench_ps.rb
+- doc/top.txt
+- examples/example_ps.rb
+- lib/freebsd/sys/proctable.rb
+- lib/sys/top.rb
 - sys-proctable.gemspec
 - test/test_sys_proctable_all.rb
-- doc/top.txt
-- ext/bsd/sys/proctable.c
-- test/test_sys_proctable_bsd.rb
-- ext/bsd/extconf.rb
+- test/test_sys_proctable_freebsd.rb
 homepage: http://www.rubyforge.org/projects/sysutils
-licenses: 
+licenses:
 - Artistic 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+- lib/freebsd
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: sysutils
-rubygems_version: 1.8.10
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: An interface for providing process table information
-test_files: 
+test_files:
 - test/test_sys_proctable_all.rb
-- test/test_sys_proctable_bsd.rb
+- test/test_sys_proctable_freebsd.rb

data/ext/bsd/extconf.rb

@@ -1,14 +0,0 @@
-require 'mkmf'
-
-have_type('rb_pid_t', 'ruby.h')
-
-have_library('kvm')
-have_func('kvm_openfiles')
-have_struct_member('struct kinfo_proc', 'kp_proc', 'sys/user.h')
-have_struct_member('struct kinfo_proc', 'kp_eproc', 'sys/user.h')
-have_struct_member('struct kinfo_proc', 'u_kproc', 'sys/user.h')
-have_struct_member('struct eproc', 'e_stats', 'sys/sysctl.h')
-have_struct_member('struct eproc', 'p_oncpu', 'sys/sysctl.h')
-have_struct_member('struct eproc', 'p_runtime', 'sys/sysctl.h')          
-
-create_makefile('sys/proctable', 'sys')

data/ext/bsd/sys/proctable.c

@@ -1,301 +0,0 @@
-/**********************************************************************
- * proctable.c
- *
- * This is a generic kvm interface used by the various BSD flavors
- * for the sys-proctable library.
- **********************************************************************/
-#include "ruby.h"
-#include <kvm.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <sys/user.h>
-
-#define SYS_PROCTABLE_VERSION "0.9.3"
-
-VALUE cProcTableError, sProcStruct;
-
-const char* fields[] = {
-  "pid", "ppid", "pgid", "ruid",
-  "rgid", "comm", "state", "pctcpu", "oncpu", "ttynum", "ttydev", "wmesg",
-  "time", "priority", "usrpri", "nice", "cmdline", "start",
-  "maxrss", "ixrss", "idrss", "isrss", "minflt", "majflt", "nswap",
-  "inblock", "oublock", "msgsnd", "msgrcv", "nsignals", "nvcsw", "nivcsw",
-  "utime", "stime"
-};
-
-/*
- * call-seq:
- *   ProcTable.ps(pid=nil)
- *   ProcTable.ps(pid=nil){ |ps| ... }
- *
- * 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+.
- */
-static VALUE pt_ps(int argc, VALUE* argv, VALUE klass){
-  kvm_t *kd;
-  char errbuf[_POSIX2_LINE_MAX];
-  char cmdline[_POSIX_ARG_MAX+1];
-  char state[8];
-  char** args = malloc(sizeof(char*));
-  struct kinfo_proc* procs;
-  int count;                     // Holds total number of processes
-  int i = 0;
-  VALUE v_pid, v_tty_num, v_tty_dev, v_start_time;
-  VALUE v_pstruct = Qnil;
-  VALUE v_array = Qnil;
-
-  rb_scan_args(argc, argv, "01", &v_pid);
-
-  if(!NIL_P(v_pid))
-    Check_Type(v_pid, T_FIXNUM);
-
-  if(!rb_block_given_p())
-    v_array = rb_ary_new();
-
-  // Open the kvm interface, get a descriptor
-  if((kd = kvm_open(NULL, NULL, NULL, 0, "kvm_open")) == NULL)
-    rb_raise(cProcTableError, "kvm_open failed: %s", strerror(errno)); 
-
-  // Get the list of processes
-  if((procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, &count)) == NULL) {
-    strcpy(errbuf, kvm_geterr(kd));
-    kvm_close(kd);
-    rb_raise(cProcTableError, errbuf);
-  }
-
-  for(i=0; i<count; i++){
-    // Reset some variables
-    v_tty_num = Qnil;
-    v_tty_dev = Qnil;
-    v_start_time = Qnil;
-
-    // If a PID is provided, skip unless the PID matches
-    if(!NIL_P(v_pid)){
-#ifdef HAVE_ST_KP_PROC
-      if(procs[i].kp_proc.p_pid != NUM2INT(v_pid))
-        continue;
-#else
-      if(procs[i].ki_pid != NUM2INT(v_pid))
-        continue;
-#endif
-      }
-
-    // Get the command line arguments for the process
-    cmdline[0] = '\0';
-    args = kvm_getargv(kd, (const struct kinfo_proc *)&procs[i], 0);
-
-    if(args){
-      int j = 0;
-      while (args[j] && strlen(cmdline) <= _POSIX_ARG_MAX) {
-        strcat(cmdline, args[j]);
-        strcat(cmdline, " ");
-        j++;
-       }
-    }
-
-    // Get the start time of the process
-    v_start_time = rb_time_new(
-#ifdef HAVE_ST_E_STATS
-      procs[i].kp_eproc.e_stats.p_start.tv_sec,
-      procs[i].kp_eproc.e_stats.p_start.tv_usec
-#else
-      0,0
-#endif
-    );
-
-    // Get the state of the process
-#ifdef HAVE_ST_KP_PROC
-    switch(procs[i].kp_proc.p_stat)
-#else
-    switch(procs[i].ki_stat)
-#endif
-    {
-      case SIDL:
-        strcpy(state, "idle");
-        break;
-      case SRUN:
-        strcpy(state, "run");
-        break;
-      case SSLEEP:
-        strcpy(state, "sleep");
-        break;
-      case SSTOP:
-        strcpy(state, "stop");
-        break;
-      case SZOMB:
-        strcpy(state, "zombie");
-        break;
-      default:
-        strcpy(state, "unknown");
-        break;
-    }
-
-    // Get ttynum and ttydev. If ttynum is -1, there is no tty
-#ifdef HAVE_ST_KP_EPROC
-    v_tty_num = INT2FIX(procs[i].kp_eproc.e_tdev),
-    v_tty_dev = rb_str_new2(devname(procs[i].kp_eproc.e_tdev, S_IFCHR));
-#elif HAVE_ST_U_KPROC
-    v_tty_num = INT2FIX(procs[i].u_kproc.ki_tdev),
-    v_tty_dev = rb_str_new2(devname(procs[i].u_kproc.ki_tdev, S_IFCHR));
-#else
-    v_tty_num = INT2FIX(procs[i].ki_tdev),
-    v_tty_dev = rb_str_new2(devname(procs[i].ki_tdev, S_IFCHR));
-#endif
-
-#ifdef HAVE_ST_KP_PROC
-    v_pstruct = rb_struct_new(
-      sProcStruct,
-      INT2FIX(procs[i].kp_proc.p_pid),
-      INT2FIX(procs[i].kp_eproc.e_ppid),
-      INT2FIX(procs[i].kp_eproc.e_pgid),
-      INT2FIX(procs[i].kp_eproc.e_pcred.p_ruid),
-      INT2FIX(procs[i].kp_eproc.e_pcred.p_rgid),
-      rb_str_new2(procs[i].kp_proc.p_comm),
-      rb_str_new2(state),
-      rb_float_new(procs[i].kp_proc.p_pctcpu),
-#ifdef HAVE_ST_P_ONCPU
-      INT2FIX(procs[i].kp_proc.p_oncpu),
-#else
-      Qnil,
-#endif
-      v_tty_num,
-      v_tty_dev,
-      rb_str_new2(procs[i].kp_eproc.e_wmesg),
-#ifdef HAVE_ST_P_RUNTIME
-      INT2FIX(procs[i].kp_proc.p_runtime/1000000),
-#else
-      Qnil,
-#endif
-      INT2FIX(procs[i].kp_proc.p_priority),
-      INT2FIX(procs[i].kp_proc.p_usrpri),
-      INT2FIX(procs[i].kp_proc.p_nice),
-      rb_str_new2(cmdline),
-      v_start_time,
-#ifdef HAVE_ST_E_STATS
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_maxrss),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_ixrss),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_idrss),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_isrss),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_minflt),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_majflt),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nswap),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_inblock),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_oublock),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_msgsnd),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_msgrcv),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nsignals),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nvcsw),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nivcsw),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_utime.tv_sec),
-      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_stime.tv_sec)
-#else
-      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil,
-      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil
-#endif
-    );
-#else
-    v_pstruct = rb_struct_new(
-      sProcStruct,
-      INT2FIX(procs[i].ki_pid),
-      INT2FIX(procs[i].ki_ppid),
-      INT2FIX(procs[i].ki_pgid),
-      INT2FIX(procs[i].ki_ruid),
-      INT2FIX(procs[i].ki_rgid),
-      rb_str_new2(procs[i].ki_ocomm),
-      rb_str_new2(state),
-      rb_float_new(procs[i].ki_pctcpu),
-      INT2FIX(procs[i].ki_oncpu),
-      v_tty_num,
-      v_tty_dev,
-      rb_str_new2(procs[i].ki_wmesg),
-      INT2FIX(procs[i].ki_runtime/1000000),
-      INT2FIX(procs[i].ki_pri.pri_level),
-      INT2FIX(procs[i].ki_pri.pri_user),
-      INT2FIX(procs[i].ki_nice),
-      rb_str_new2(cmdline),
-      v_start_time,
-      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil,
-      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil
-    );
-#endif
-
-    OBJ_FREEZE(v_pstruct); // Read-only data
-
-    if(rb_block_given_p())
-      rb_yield(v_pstruct);
-    else
-      rb_ary_push(v_array, v_pstruct);
-  }
-
-  if(kd)
-    kvm_close(kd);
-
-  if(!NIL_P(v_pid))
-    return v_pstruct;
-
-  return v_array; // Nil if block given
-}
-
-/*
- * call-seq:
- *    ProcTable.fields
- *
- * 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 /proc table.
- */
-static VALUE pt_fields(VALUE klass){
-   VALUE v_array = rb_ary_new();
-   int size = sizeof(fields) / sizeof(fields[0]);
-   int i;
-
-   for(i = 0; i < size; i++)
-      rb_ary_push(v_array, rb_str_new2(fields[i]));
-
-   return v_array;
-}
-
-/*
- * A Ruby interface for gathering process table information.
- */
-void Init_proctable(){
-   VALUE mSys, cProcTable;
-
-   /* The Sys module serves as a namespace only */
-   mSys = rb_define_module("Sys");
-
-   /* The ProcTable class encapsulates process table information */
-   cProcTable = rb_define_class_under(mSys, "ProcTable", rb_cObject);
-
-   /* The error typically raised if any of the ProcTable methods fail */
-   cProcTableError = rb_define_class_under(cProcTable, "Error", rb_eStandardError);
-
-   /* Singleton Methods */
-
-   rb_define_singleton_method(cProcTable, "ps", pt_ps, -1);
-   rb_define_singleton_method(cProcTable, "fields", pt_fields, 0);
-
-   /* There is no constructor */
-   rb_funcall(cProcTable, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
-
-   /* Constants */
-
-   /* 0.9.3: The version of the sys-proctable library */
-   rb_define_const(cProcTable, "VERSION", rb_str_new2(SYS_PROCTABLE_VERSION));
-
-   /* Structures */
-
-   sProcStruct = rb_struct_define("ProcTableStruct","pid","ppid","pgid","ruid",
-      "rgid","comm","state","pctcpu","oncpu","ttynum","ttydev","wmesg",
-      "time", "priority","usrpri","nice","cmdline","start",
-      "maxrss","ixrss","idrss","isrss","minflt","majflt","nswap",
-      "inblock","oublock","msgsnd","msgrcv","nsignals","nvcsw","nivcsw",
-      "utime","stime", NULL
-   );
-}