sys-proctable 0.9.1-universal-linux

data/lib/sys/top.rb

@@ -0,0 +1,32 @@
+require 'sys/proctable'
+require 'rbconfig'
+
+# 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.3'
+
+    # 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.
+    #
+    def self.top(num=10, field='pctcpu')
+      field = field.to_s if field.is_a?(Symbol)
+
+      windows = /mswin|win32|windows|dos|cygwin|mingw/i
+
+      # Sort by pid on Windows by default
+      if Config::CONFIG['host_os'].match(windows) && 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,39 @@
+require 'rubygems'
+require 'rbconfig'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'sys-proctable'
+  spec.version    = '0.9.1'
+  spec.author     = 'Daniel J. Berger'
+  spec.license    = 'Artistic 2.0' 
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'http://www.rubyforge.org/projects/sysutils'
+  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']
+   
+  # Additional files for your platform are added by the 'rake gem' task.
+  spec.files = [
+    'benchmarks/bench_ps.rb',
+    'examples/example_ps.rb',
+    'lib/sys/top.rb',
+    'CHANGES',
+    'MANIFEST',
+    'Rakefile',
+    'README',
+    'sys-proctable.gemspec'
+  ]
+
+  spec.rubyforge_project = 'sysutils'
+  spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST', 'doc/top.txt']
+
+  spec.add_development_dependency('test-unit', '>= 2.1.2')
+
+  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,85 @@
+#######################################################################
+# 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 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'sys/proctable'
+require 'rbconfig'
+require 'test/test_sys_top'
+include Sys
+
+class TC_ProcTable_All < Test::Unit::TestCase
+  def self.startup
+    @@windows = Config::CONFIG['host_os'] =~ /windows|win32|msdos|mswin32|mingw|cygwin/i
+  end
+
+  def setup
+    @pid = @@windows ? 0 : 1
+  end
+
+  def test_version
+    assert_equal('0.9.1', 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 teardown
+    @pid  = nil
+  end
+
+  def self.teardown
+    @@windows = nil
+  end
+end

data/test/test_sys_proctable_linux.rb

@@ -0,0 +1,298 @@
+#######################################################################
+# test_sys_proctable_linux.rb
+#
+# Test suite for the Linux version of the sys-proctable library. You
+# should run these tests via the 'rake test' task.
+#######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'sys/proctable'
+require 'test/test_sys_proctable_all'
+include Sys
+
+class TC_ProcTable_Linux < Test::Unit::TestCase
+  def self.startup
+    @@fields = %w/
+      cmdline cwd exe pid name uid euid gid egid comm state ppid pgrp
+      session tty_num tpgid flags minflt cminflt majflt cmajflt utime
+      stime cutime cstime priority nice itrealvalue starttime vsize
+      rss rlim startcode endcode startstack kstkesp kstkeip signal blocked
+      sigignore sigcatch wchan nswap cnswap exit_signal processor environ
+      pctcpu pctmem
+      /
+  end
+
+  def setup
+    @ptable = ProcTable.ps.last
+  end
+
+  def test_cmdline
+    assert_respond_to(@ptable, :cmdline)
+    assert_kind_of(String, @ptable.cmdline)
+  end
+
+  def test_cwd
+    assert_respond_to(@ptable, :cwd)
+    assert_true([NilClass, String].include?(@ptable.cwd.class))
+  end
+
+  def test_environ
+    assert_respond_to(@ptable, :environ)
+    assert_kind_of(Hash, @ptable.environ)
+  end
+
+  def test_exe
+    assert_respond_to(@ptable, :exe)
+    assert_kind_of(String, @ptable.exe)
+  end
+
+  def test_fd
+    assert_respond_to(@ptable, :fd)
+    assert_kind_of(Hash, @ptable.fd)
+  end
+
+  def test_root
+    assert_respond_to(@ptable, :root)
+    assert_kind_of(String, @ptable.root)
+  end
+
+  def test_pid
+    assert_respond_to(@ptable, :pid)
+    assert_kind_of(Fixnum, @ptable.pid)
+  end
+
+  def test_comm
+    assert_respond_to(@ptable, :comm)
+    assert_kind_of(String, @ptable.comm)
+  end
+
+  def test_state
+    assert_respond_to(@ptable, :state)
+    assert_kind_of(String, @ptable.state)
+  end
+
+  def test_ppid
+    assert_respond_to(@ptable, :ppid)
+    assert_kind_of(Fixnum, @ptable.ppid)
+  end
+
+  def test_pgrp
+    assert_respond_to(@ptable, :pgrp)
+    assert_kind_of(Fixnum, @ptable.pgrp)
+  end
+
+  def test_session
+    assert_respond_to(@ptable, :session)
+    assert_kind_of(Fixnum, @ptable.session)
+  end
+
+  def test_tty_nr
+    assert_respond_to(@ptable, :tty_nr)
+    assert_kind_of(Fixnum, @ptable.tty_nr)
+  end
+
+  def test_tpgid
+    assert_respond_to(@ptable, :tpgid)
+    assert_kind_of(Fixnum, @ptable.tpgid)
+  end
+
+  def test_flags
+    assert_respond_to(@ptable, :flags)
+    assert_kind_of(Fixnum, @ptable.flags)
+  end
+
+  def test_minflt
+    assert_respond_to(@ptable, :minflt)
+    assert_kind_of(Fixnum, @ptable.minflt)
+  end
+
+  def test_cminflt
+    assert_respond_to(@ptable, :cminflt)
+    assert_kind_of(Fixnum, @ptable.cminflt)
+  end
+
+  def test_majflt
+    assert_respond_to(@ptable, :majflt)
+    assert_kind_of(Fixnum, @ptable.majflt)
+  end
+
+  def test_cmajflt
+    assert_respond_to(@ptable, :cmajflt)
+    assert_kind_of(Fixnum, @ptable.cmajflt)
+  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_cutime
+    assert_respond_to(@ptable, :cutime)
+    assert_kind_of(Fixnum, @ptable.cutime)
+  end
+
+  def test_cstime
+    assert_respond_to(@ptable, :cstime)
+    assert_kind_of(Fixnum, @ptable.cstime)
+  end
+
+  def test_priority
+    assert_respond_to(@ptable, :priority)
+    assert_kind_of(Fixnum, @ptable.priority)
+  end
+
+  def test_nice
+    assert_respond_to(@ptable, :nice)
+    assert_kind_of(Fixnum, @ptable.nice)
+  end
+
+  def test_itrealvalue
+    assert_respond_to(@ptable, :itrealvalue)
+    assert_kind_of(Fixnum, @ptable.itrealvalue)
+  end
+
+  def test_starttime
+    assert_respond_to(@ptable, :starttime)
+    assert_kind_of(Fixnum, @ptable.starttime)
+  end
+
+  def test_vsize
+    assert_respond_to(@ptable, :vsize)
+    assert_kind_of(Fixnum, @ptable.vsize)
+  end
+
+  def test_rss
+    assert_respond_to(@ptable, :rss)
+    assert_kind_of(Fixnum, @ptable.rss)
+  end
+
+  def test_rlim
+    assert_respond_to(@ptable, :rlim)
+    assert_kind_of(Integer, @ptable.rlim)
+  end
+
+  def test_startcode
+    assert_respond_to(@ptable, :startcode)
+    assert_kind_of(Fixnum, @ptable.startcode)
+  end
+
+  def test_endcode
+    assert_respond_to(@ptable, :endcode)
+    assert_kind_of(Fixnum, @ptable.endcode)
+  end
+
+  def test_startstack
+    assert_respond_to(@ptable, :startstack)
+    assert_kind_of(Integer, @ptable.startstack)
+  end
+
+  def test_kstkesp
+    assert_respond_to(@ptable, :kstkesp)
+    assert_kind_of(Integer, @ptable.kstkesp)
+  end
+
+  def test_kstkeip
+    assert_respond_to(@ptable, :kstkeip)
+    assert_kind_of(Integer, @ptable.kstkeip)
+  end
+
+  def test_signal
+    assert_respond_to(@ptable, :signal)
+    assert_kind_of(Integer, @ptable.signal)
+  end
+
+  def test_blocked
+    assert_respond_to(@ptable, :blocked)
+    assert_kind_of(Fixnum, @ptable.blocked)
+  end
+
+  def test_sigignore
+    assert_respond_to(@ptable, :sigignore)
+    assert_kind_of(Fixnum, @ptable.sigignore)
+  end
+
+  def test_sigcatch
+    assert_respond_to(@ptable, :sigcatch)
+    assert_kind_of(Numeric, @ptable.sigcatch)
+  end
+
+  def test_wchan
+    assert_respond_to(@ptable, :wchan)
+    assert_kind_of(Numeric, @ptable.wchan)
+  end
+
+  def test_nswap
+    assert_respond_to(@ptable, :nswap)
+    assert_kind_of(Fixnum, @ptable.nswap)
+  end
+
+  def test_cnswap
+    assert_respond_to(@ptable, :cnswap)
+    assert_kind_of(Fixnum, @ptable.cnswap)
+  end
+
+  def test_exit_signal
+    assert_respond_to(@ptable, :exit_signal)
+    assert_kind_of(Fixnum, @ptable.exit_signal)
+  end
+
+  def test_processor
+    assert_respond_to(@ptable, :processor)
+    assert_kind_of(Fixnum, @ptable.processor)
+  end
+
+  def test_rt_priority
+    assert_respond_to(@ptable, :rt_priority)
+    assert_kind_of(Fixnum, @ptable.rt_priority)
+  end
+
+  def test_policy
+    assert_respond_to(@ptable, :policy)
+    assert_kind_of(Fixnum, @ptable.policy)
+  end
+
+  def test_name
+    assert_respond_to(@ptable, :name)
+    assert_kind_of(String, @ptable.name)
+  end
+
+  def test_uid
+    assert_respond_to(@ptable, :uid)
+    assert_kind_of(Fixnum, @ptable.uid)
+  end
+
+  def test_euid
+    assert_respond_to(@ptable, :euid)
+    assert_kind_of(Fixnum, @ptable.euid)
+  end
+
+  def test_gid
+    assert_respond_to(@ptable, :gid)
+    assert_kind_of(Fixnum, @ptable.gid)
+  end
+
+  def test_egid
+    assert_respond_to(@ptable, :egid)
+    assert_kind_of(Fixnum, @ptable.egid)
+  end
+
+  def test_pctmem
+    assert_respond_to(@ptable, :pctmem)
+    assert_kind_of(Float, @ptable.pctmem)
+  end
+
+  def test_pctcpu
+    assert_respond_to(@ptable, :pctcpu)
+    assert_kind_of(Float, @ptable.pctcpu)
+  end
+
+  def teardown
+    @ptable = nil
+  end
+end