sys-proctable 0.9.9-universal-hpux

data/lib/sys-proctable.rb

@@ -0,0 +1 @@
+require 'sys/proctable'

data/lib/sys/proctable/version.rb

@@ -0,0 +1,6 @@
+module Sys
+  class ProcTable
+    # The version of the sys-proctable library
+    VERSION = '0.9.9'
+  end
+end

data/lib/sys/top.rb

@@ -0,0 +1,31 @@
+require 'sys/proctable'
+
+# The Sys module serves as a namespace only
+module Sys
+
+  # The Top class serves as a toplevel name for the 'top' method.
+  class Top
+
+    # The version of the sys-top library
+    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 AIX and Windows.
+    #
+    def self.top(num=10, field='pctcpu')
+      field = field.to_s if field.is_a?(Symbol)
+
+      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
+
+      Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+    end
+  end
+end

data/sys-proctable.gemspec

@@ -0,0 +1,40 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'sys-proctable'
+  spec.version    = '0.9.9'
+  spec.author     = 'Daniel J. Berger'
+  spec.license    = 'Artistic 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
+  spec.summary    = 'An interface for providing process table information'
+  spec.test_files = ['test/test_sys_proctable_all.rb']
+  spec.cert_chain = ['certs/djberg96_pub.pem']
+   
+  # Additional files for your platform are added by the 'rake gem' task.
+  spec.files = [
+    'benchmarks/bench_ps.rb',
+    'examples/example_ps.rb',
+    'lib/sys/proctable/version.rb',
+    'lib/sys/top.rb',
+    'CHANGES',
+    'MANIFEST',
+    'Rakefile',
+    'README',
+    'sys-proctable.gemspec'
+  ]
+
+  spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST', 'doc/top.txt']
+
+  spec.add_development_dependency('test-unit')
+  spec.add_development_dependency('rake')
+
+  spec.description = <<-EOF
+    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.
+  EOF
+end

data/test/test_sys_proctable_all.rb

@@ -0,0 +1,87 @@
+#######################################################################
+# test_sys_proctable_all.rb
+#
+# Test suite for methods common to all platforms. Generally speaking
+# you should run this test case using the 'rake test' task.
+#######################################################################
+require 'test-unit'
+require 'sys/proctable'
+require 'test/test_sys_top'
+include Sys
+
+class TC_ProcTable_All < Test::Unit::TestCase
+  def self.startup
+    @@windows = File::ALT_SEPARATOR
+  end
+
+  def setup
+    @pid = @@windows ? 0 : 1
+  end
+
+  def test_version
+    assert_equal('0.9.9', ProcTable::VERSION)
+  end
+
+  def test_fields
+    assert_respond_to(ProcTable, :fields)
+    assert_nothing_raised{ ProcTable.fields }
+    assert_kind_of(Array, ProcTable.fields)
+    assert_kind_of(String, ProcTable.fields.first)
+  end
+
+  def test_ps
+    assert_respond_to(ProcTable, :ps)
+    assert_nothing_raised{ ProcTable.ps }
+    assert_nothing_raised{ ProcTable.ps{} }
+  end
+
+  def test_ps_with_pid
+    assert_nothing_raised{ ProcTable.ps(0) }
+  end
+
+  def test_ps_with_explicit_nil
+    assert_nothing_raised{ ProcTable.ps(nil) }
+    assert_kind_of(Array, ProcTable.ps(nil))
+  end
+
+  def test_ps_return_value
+    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
+    assert_true(ProcTable.ps.first.frozen?)
+  end
+
+  def test_ps_expected_errors
+    assert_raises(TypeError){ ProcTable.ps('vim') }
+    omit_if(@@windows, 'ArgumentError check skipped on MS Windows')
+    assert_raises(ArgumentError){ ProcTable.ps(0, 'localhost') }
+  end
+
+  def test_new_not_allowed
+    assert_raise(NoMethodError){ Sys::ProcTable.new }
+  end
+
+  def test_error_class_defined
+    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
+  end
+
+  def teardown
+    @pid  = nil
+  end
+
+  def self.teardown
+    @@windows = nil
+  end
+end

data/test/test_sys_proctable_hpux.rb

@@ -0,0 +1,313 @@
+#######################################################################
+# test_sys_proctable_hpux.rb
+#
+# Test case for the HP-UX version of the sys-proctable library. You
+# should run this test suite via the 'rake test' task.
+#######################################################################
+require 'rubygems'
+gem 'test/unit'
+
+require 'sys/proctable'
+require 'test/test_sys_proctable_all'
+include Sys
+
+class TC_ProcTable_HPUX < Test::Unit::TestCase
+   def self.startup
+      @@fields = %w/
+         comm uid pid ppid dsize tsize ssize nice ttydev pgrp pri addr
+         cpu utime stime start flag stat wchan procnum cmd cmdline time
+         cpticks cptickstotal fss pctcpu rssize suid shmsize mmsize usize
+         iosize vtsize vdsize vssize vshmsize vmmsize vusize viosize
+         minorfaults majorfaults nswap nsignals msgrcv msgsnd maxrss
+         sid schedpolicy ticksleft euid egid gid sgid        
+      /
+   end
+
+   def setup
+      @ptable = ProcTable.ps.last
+   end
+
+   def test_expected_fields
+      assert_respond_to(ProcTable, :fields)
+      assert_kind_of(Array, ProcTable.fields)
+      assert_equal(@@fields, ProcTable.fields)
+   end
+
+   def test_comm
+      assert_respond_to(@ptable, :comm)
+      assert_kind_of(String, @ptable.comm)
+   end
+
+   def test_uid
+      assert_respond_to(@ptable, :uid)
+      assert_kind_of(Fixnum, @ptable.uid)
+   end
+
+   def test_pid
+      assert_respond_to(@ptable, :pid)
+      assert_kind_of(Fixnum, @ptable.pid)
+   end
+
+   def test_ppid
+      assert_respond_to(@ptable, :ppid)
+      assert_kind_of(Fixnum, @ptable.ppid)
+   end
+
+   def test_dsize
+      assert_respond_to(@ptable, :dsize)
+      assert_kind_of(Fixnum, @ptable.dsize)
+   end
+
+   def test_tsize
+      assert_respond_to(@ptable, :tsize)
+      assert_kind_of(Fixnum, @ptable.tsize)
+   end
+
+   def test_ssize
+      assert_respond_to(@ptable, :ssize)
+      assert_kind_of(Fixnum, @ptable.ssize)
+   end
+
+   def test_nice
+      assert_respond_to(@ptable, :nice)
+      assert_kind_of(Fixnum, @ptable.nice)
+   end
+
+   def test_ttydev
+      assert_respond_to(@ptable, :ttydev)
+      assert_kind_of(String, @ptable.ttydev)
+   end
+
+   def test_pgrp
+      assert_respond_to(@ptable, :pgrp)
+      assert_kind_of(Fixnum, @ptable.pgrp)
+   end
+
+   def test_pri
+      assert_respond_to(@ptable, :pri)
+      assert_kind_of(Fixnum, @ptable.pri)
+   end
+
+   def test_addr
+      assert_respond_to(@ptable, :addr)
+      assert_kind_of(Fixnum, @ptable.addr)
+   end
+
+   def test_cpu
+      assert_respond_to(@ptable, :cpu)
+      assert_kind_of(Fixnum, @ptable.cpu)
+   end
+
+   def test_utime
+      assert_respond_to(@ptable, :utime)
+      assert_kind_of(Fixnum, @ptable.utime)
+   end
+
+   def test_stime
+      assert_respond_to(@ptable, :stime)
+      assert_kind_of(Fixnum, @ptable.stime)
+   end
+
+   def test_start
+      assert_respond_to(@ptable, :start)
+      assert_kind_of(Time, @ptable.start)
+   end
+
+   def test_flag
+      assert_respond_to(@ptable, :flag)
+      assert_kind_of(Fixnum, @ptable.flag)
+   end
+
+   def test_state
+      assert_respond_to(@ptable, :state)
+      assert_kind_of(String, @ptable.state)
+   end
+
+   def test_wchan
+      assert_respond_to(@ptable, :wchan)
+      assert_kind_of(Fixnum, @ptable.wchan)
+   end
+
+   def test_procnum
+      assert_respond_to(@ptable, :procnum)
+      assert_kind_of(Fixnum, @ptable.procnum)
+   end
+
+   def test_cmd
+      assert_respond_to(@ptable, :cmd)
+      assert_kind_of(String, @ptable.cmd)
+   end
+
+   def test_cmdline
+      assert_respond_to(@ptable, :cmdline)
+      assert_kind_of(String, @ptable.cmdline)
+   end
+
+   def test_time
+      assert_respond_to(@ptable, :time)
+      assert_kind_of(Fixnum, @ptable.time)
+   end
+
+   def test_cpticks
+      assert_respond_to(@ptable, :cpticks)
+      assert_kind_of(Fixnum, @ptable.cpticks)
+   end
+
+   def test_cptickstotal
+      assert_respond_to(@ptable, :cptickstotal)
+      assert_kind_of(Fixnum, @ptable.cptickstotal)
+   end
+
+   def test_fss
+      assert_respond_to(@ptable, :fss)
+      assert_kind_of(Fixnum, @ptable.fss)
+   end
+
+   def test_pctcpu
+      assert_respond_to(@ptable, :pctcpu)
+      assert_kind_of(Float, @ptable.pctcpu)
+   end
+
+   def test_rssize
+      assert_respond_to(@ptable, :rssize)
+      assert_kind_of(Fixnum, @ptable.rssize)
+   end
+
+   def test_suid
+      assert_respond_to(@ptable, :suid)
+      assert_kind_of(Fixnum, @ptable.suid)
+   end
+
+   def test_shmsize
+      assert_respond_to(@ptable, :shmsize)
+      assert_kind_of(Fixnum, @ptable.shmsize)
+   end
+
+   def test_mmsize
+      assert_respond_to(@ptable, :mmsize)
+      assert_kind_of(Fixnum, @ptable.mmsize)
+   end
+
+   def test_usize
+      assert_respond_to(@ptable, :usize)
+      assert_kind_of(Fixnum, @ptable.usize)
+   end
+
+   def test_iosize
+      assert_respond_to(@ptable, :iosize)
+      assert_kind_of(Fixnum, @ptable.iosize)
+   end
+
+   def test_vtsize
+      assert_respond_to(@ptable, :vtsize)
+      assert_kind_of(Fixnum, @ptable.vtsize)
+   end
+
+   def test_vdsize
+      assert_respond_to(@ptable, :vdsize)
+      assert_kind_of(Fixnum, @ptable.vdsize)
+   end
+
+   def test_vssize
+      assert_respond_to(@ptable, :vssize)
+      assert_kind_of(Fixnum, @ptable.vssize)
+   end
+
+   def test_vshmsize
+      assert_respond_to(@ptable, :vshmsize)
+      assert_kind_of(Fixnum, @ptable.vshmsize)
+   end
+
+   def test_vmmsize
+      assert_respond_to(@ptable, :vmmsize)
+      assert_kind_of(Fixnum, @ptable.vmmsize)
+   end
+
+   def test_vusize
+      assert_respond_to(@ptable, :vusize)
+      assert_kind_of(Fixnum, @ptable.vusize)
+   end
+
+   def test_viosize
+      assert_respond_to(@ptable, :viosize)
+      assert_kind_of(Fixnum, @ptable.viosize)
+   end
+
+   def test_minorfaults
+      assert_respond_to(@ptable, :minorfaults)
+      assert_kind_of(Integer, @ptable.minorfaults)
+   end
+
+   def test_majorfaults
+      assert_respond_to(@ptable, :majorfaults)
+      assert_kind_of(Integer, @ptable.majorfaults)
+   end
+
+   def test_nswap
+      assert_respond_to(@ptable, :nswap)
+      assert_kind_of(Integer, @ptable.nswap)
+   end
+
+   def test_nsignals
+      assert_respond_to(@ptable, :nsignals)
+      assert_kind_of(Integer, @ptable.nsignals)
+   end
+
+   def test_msgrcv
+      assert_respond_to(@ptable, :msgrcv)
+      assert_kind_of(Integer, @ptable.msgrcv)
+   end
+
+   def test_msgsnd
+      assert_respond_to(@ptable, :msgsnd)
+      assert_kind_of(Integer, @ptable.msgsnd)
+   end
+
+   def test_maxrss
+      assert_respond_to(@ptable, :maxrss)
+      assert_kind_of(Fixnum, @ptable.maxrss)
+   end
+
+   def test_sid
+      assert_respond_to(@ptable, :sid)
+      assert_kind_of(Fixnum, @ptable.sid)
+   end
+
+   def test_schedpolicy
+      assert_respond_to(@ptable, :schedpolicy)
+      assert_kind_of(Fixnum, @ptable.schedpolicy)
+   end
+
+   def test_ticksleft
+      assert_respond_to(@ptable, :ticksleft)
+      assert_kind_of(Fixnum, @ptable.ticksleft)
+   end
+
+   def test_euid
+      assert_respond_to(@ptable, :euid)
+      assert_kind_of(Fixnum, @ptable.euid)
+   end
+
+   def test_egid
+      assert_respond_to(@ptable, :egid)
+      assert_kind_of(Fixnum, @ptable.egid)
+   end
+
+   def test_gid
+      assert_respond_to(@ptable, :gid)
+      assert_kind_of(Fixnum, @ptable.gid)
+   end
+
+   def test_sgid
+      assert_respond_to(@ptable, :sgid)
+      assert_kind_of(Fixnum, @ptable.sgid)
+   end
+
+   def teardown
+      @ptable = nil
+   end
+
+   def self.shutdown
+      @@fields = nil
+   end
+end