sys-proctable 0.9.2-universal-mingw

data/Rakefile

@@ -0,0 +1,174 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rbconfig'
+include RbConfig
+
+CLEAN.include(
+  '**/*.core',              # Core dump files
+  '**/*.gem',               # Gem files
+  '**/*.rbc',               # Rubinius
+  '.rbx', '**/*/.rbx',      # Rubinius
+  '**/*.o',                 # C object file
+  '**/*.log',               # Ruby extension build log
+  '**/Makefile',            # C Makefile
+  '**/conftest.dSYM',       # OS X build directory
+  "**/*.#{CONFIG['DLEXT']}" # C shared object
+)
+
+desc 'Build the sys-proctable library for C versions of sys-proctable'
+task :build => [:clean] do
+  case CONFIG['host_os']
+    when /bsd/i
+      dir = 'ext/bsd'
+    when /darwin/i
+      dir = 'ext/darwin'
+    when /hpux/i
+      dir = 'ext/hpux'
+  end
+
+  unless CONFIG['host_os'] =~ /win32|mswin|dos|cygwin|mingw|windows|linux|sunos|solaris/i
+    Dir.chdir(dir) do
+      ruby 'extconf.rb'
+      sh 'make'
+      cp 'proctable.' + CONFIG['DLEXT'], 'sys'
+    end
+  end
+end
+
+desc 'Install the sys-proctable library'
+task :install => [:build] do
+  file = nil
+  dir  = File.join(CONFIG['sitelibdir'], 'sys')
+
+  Dir.mkdir(dir) unless File.exists?(dir)
+
+  case CONFIG['host_os']
+    when /mswin|win32|msdos|cygwin|mingw|windows/i
+      file = 'lib/windows/sys/proctable.rb'
+    when /linux/i
+      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 /darwin/i
+      Dir.chdir('ext/darwin'){ sh 'make install' }
+    when /hpux/i
+      Dir.chdir('ext/hpux'){ sh 'make install' }
+  end
+
+  cp(file, dir, :verbose => true) if file
+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
+      dir  = File.join(CONFIG['sitearchdir'], 'sys')
+      file = File.join(dir, 'proctable.' + CONFIG['DLEXT'])
+  end
+
+  rm(file) 
+end
+
+desc 'Run the benchmark suite'
+task :bench => [:build] do
+  sh "ruby -Ilib benchmarks/bench_ps.rb"
+end
+
+desc 'Run the example program'
+task :example => [:build] do
+  sh 'ruby -Ilib -Iext examples/example_ps.rb'
+end
+
+desc 'Run the test suite'
+Rake::TestTask.new do |t|
+  task :test => :build
+  t.libs << 'test' << '.'
+   
+  case CONFIG['host_os']
+    when /mswin|msdos|cygwin|mingw|windows/i
+      t.test_files = FileList['test/test_sys_proctable_windows.rb']
+      t.libs << 'lib/windows'
+    when /linux/i
+      t.test_files = FileList['test/test_sys_proctable_linux.rb']
+      t.libs << 'lib/linux'
+    when /sunos|solaris/i
+      t.test_files = FileList['test/test_sys_proctable_sunos.rb']
+      t.libs << 'lib/sunos'
+    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']  
+  end
+end
+
+namespace :gem do
+  desc 'Create a gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('sys-proctable.gemspec'))
+
+    # I've had to manually futz with the spec here in some cases
+    # in order to get the universal platform settings I want because
+    # of some bugginess in Rubygems' platform.rb.
+    #
+    case CONFIG['host_os']
+      when /bsd/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']
+      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.test_files << 'test/test_sys_proctable_darwin.rb'
+         spec.extensions = ['ext/darwin/extconf.rb']
+      when /hpux/i
+         spec.platform = Gem::Platform.new(['universal', 'hpux'])
+         spec.files << 'ext/hpux/sys/proctable.c'
+         spec.extra_rdoc_files << 'ext/hpux/sys/proctable.c'
+         spec.test_files << 'test/test_sys_proctable_hpux.rb'
+         spec.extensions = ['ext/hpux/extconf.rb']
+      when /linux/i
+         spec.platform = Gem::Platform.new(['universal', 'linux'])
+         spec.require_paths = ['lib', 'lib/linux']
+         spec.files += ['lib/linux/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_linux.rb'
+      when /sunos|solaris/i
+         spec.platform = Gem::Platform.new(['universal', 'solaris'])
+         spec.require_paths = ['lib', 'lib/sunos']
+         spec.files += ['lib/sunos/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_sunos.rb'
+      when /mswin|win32|dos|cygwin|mingw|windows/i
+         spec.platform = Gem::Platform.new(['universal', 'mingw'])
+         spec.require_paths = ['lib', 'lib/windows']
+         spec.files += ['lib/windows/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_windows.rb'
+    end
+ 
+    # https://github.com/rubygems/rubygems/issues/147
+    spec.original_platform = spec.platform
+
+    Gem::Builder.new(spec).build
+  end
+
+  desc 'Install the sys-proctable library as a gem'
+  task :install => [:create] do
+    gem_name = Dir['*.gem'].first
+    sh "gem install #{gem_name}"
+  end
+end
+
+task :default => :test

data/benchmarks/bench_ps.rb

@@ -0,0 +1,21 @@
+########################################################################
+# bench_ps.rb
+#
+# Benchmark program to show overall speed and compare the block form
+# versus the non-block form. You should run this benchmark via the
+# 'rake bench' Rake task.
+########################################################################
+require 'benchmark'
+require 'sys/proctable'
+
+MAX = 10
+
+Benchmark.bm do |bench|
+   bench.report("Block form"){
+      MAX.times{ Sys::ProcTable.ps{} }
+   }
+
+   bench.report("Non-block form"){
+      MAX.times{ Sys::ProcTable.ps }
+   }
+end

data/doc/top.txt

@@ -0,0 +1,47 @@
+= Description
+   A simple 'top' interface for Ruby
+
+= Prerequisites
+   Requires the "sys/proctable" package (which should be installed along
+   with this package).
+
+= Synopsis
+   require "sys/top"
+
+   Sys::Top.top(5).each{ |ps|
+      p ps
+   }
+	
+= Constants
+VERSION
+   Returns the version number of this package as a String.
+	
+= Class Methods
+Sys::Top.top(number=10, field="pctcpu")
+   Returns an array of ProcTableStruct's.  The size of the array (i.e. the
+   number of processes) that it returns is based on +number+, and sorted by
+   +pctcpu+.  By default, the size and field values are 10 and "pctcpu",
+   respectively.
+
+= Notes
+   Not all fields are available on all platforms.  Please check your
+   platform specific documentation for which fields are available.
+	
+= Bugs
+   None that I'm aware of.  Please log bug reports on the project page at
+   http://www.rubyforge.org/projects/sysutils
+	
+= License
+   Artistic 2.0
+	
+= Copyright
+   (C) 2004-2009 Daniel J. Berger
+   All Rights Reserved.
+    
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+= Author
+   Daniel J. Berger

data/examples/example_ps.rb

@@ -0,0 +1,20 @@
+#######################################################################
+# example_ps.rb
+#
+# Generic test program that demonstrates the use of ProcTable.ps. You
+# can run this via the 'rake example' task.
+#
+# Modify as you see fit
+#######################################################################
+require 'sys/proctable'
+include Sys
+
+puts "VERSION: " + ProcTable::VERSION
+sleep 2
+
+ProcTable.ps{ |s|
+   ProcTable.fields.each{ |field|
+      puts "#{field}: " + s.send(field).to_s    
+   }
+   puts '=' * 30
+}

data/lib/sys/top.rb

@@ -0,0 +1,29 @@
+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.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)
+
+      # Sort by pid on Windows by default
+      if File::ALT_SEPARATOR && field == 'pctcpu'
+        field = 'pid'
+      end
+
+      Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+    end
+  end
+end

data/lib/windows/sys/proctable.rb

@@ -0,0 +1,209 @@
+require 'win32ole'
+require 'socket'
+require 'date'
+
+# The Sys module serves as a namespace only
+module Sys
+
+  # The ProcTable class encapsulates process table information
+  class ProcTable
+
+    # There is no constructor
+    private_class_method :new
+
+    # Error typically raised if one of the Sys::ProcTable methods fails
+    class Error < StandardError; end
+
+    # The version of the sys-proctable library
+    VERSION = '0.9.2'
+
+    # The comm field corresponds to the 'name' field.  The 'cmdline' field
+    # is the CommandLine attribute on Windows XP or later, or the
+    # 'executable_path' field on Windows 2000 or earlier.
+    #
+    @fields = %w[
+      caption
+      cmdline
+      comm
+      creation_class_name
+      creation_date
+      cs_creation_class_name
+      cs_name
+      description
+      executable_path
+      execution_state
+      handle
+      handle_count
+      install_date
+      kernel_mode_time
+      maximum_working_set_size
+      minimum_working_set_size
+      name
+      os_creation_class_name
+      os_name
+      other_operation_count
+      other_transfer_count
+      page_faults
+      page_file_usage
+      ppid
+      peak_page_file_usage
+      peak_virtual_size
+      peak_working_set_size
+      priority
+      private_page_count
+      pid
+      quota_non_paged_pool_usage
+      quota_paged_pool_usage
+      quota_peak_non_paged_pool_usage
+      quota_peak_paged_pool_usage
+      read_operation_count
+      read_transfer_count
+      session_id
+      status
+      termination_date
+      thread_count
+      user_mode_time
+      virtual_size
+      windows_version
+      working_set_size
+      write_operation_count
+      write_transfer_count
+    ]
+
+    ProcTableStruct = Struct.new("ProcTableStruct", *@fields)
+
+    # 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.
+    #
+    def self.fields
+       @fields
+    end
+
+    # 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+.
+    #
+    def self.ps(pid=nil, host=Socket.gethostname)
+      if pid
+        raise TypeError unless pid.kind_of?(Fixnum)
+      end
+
+      array  = block_given? ? nil : []
+      struct = nil
+
+      begin
+        wmi = WIN32OLE.connect("winmgmts://#{host}/root/cimv2")
+      rescue WIN32OLERuntimeError => e
+        raise Error, e # Re-raise as ProcTable::Error
+      else
+        wmi.InstancesOf("Win32_Process").each{ |wproc|
+          if pid
+            next unless wproc.ProcessId == pid
+          end
+
+          # Some fields are added later, and so are nil initially
+          struct = ProcTableStruct.new(
+            wproc.Caption,
+            nil, # Added later, based on OS version
+            wproc.Name,
+            wproc.CreationClassName,
+            self.parse_ms_date(wproc.CreationDate),
+            wproc.CSCreationClassName,
+            wproc.CSName,
+            wproc.Description,
+            wproc.ExecutablePath,
+            wproc.ExecutionState,
+            wproc.Handle,
+            wproc.HandleCount,
+            self.parse_ms_date(wproc.InstallDate),
+            self.convert(wproc.KernelModeTime),
+            wproc.MaximumWorkingSetSize,
+            wproc.MinimumWorkingSetSize,
+            wproc.Name,
+            wproc.OSCreationClassName,
+            wproc.OSName,
+            self.convert(wproc.OtherOperationCount),
+            self.convert(wproc.OtherTransferCount),
+            wproc.PageFaults,
+            wproc.PageFileUsage,
+            wproc.ParentProcessId,
+            self.convert(wproc.PeakPageFileUsage),
+            self.convert(wproc.PeakVirtualSize),
+            self.convert(wproc.PeakWorkingSetSize),
+            wproc.Priority,
+            self.convert(wproc.PrivatePageCount),
+            wproc.ProcessId,
+            wproc.QuotaNonPagedPoolUsage,
+            wproc.QuotaPagedPoolUsage,
+            wproc.QuotaPeakNonPagedPoolUsage,
+            wproc.QuotaPeakPagedPoolUsage,
+            self.convert(wproc.ReadOperationCount),
+            self.convert(wproc.ReadTransferCount),
+            wproc.SessionId,
+            wproc.Status,
+            self.parse_ms_date(wproc.TerminationDate),
+            wproc.ThreadCount,
+            self.convert(wproc.UserModeTime),
+            self.convert(wproc.VirtualSize),
+            wproc.WindowsVersion,
+            self.convert(wproc.WorkingSetSize),
+            self.convert(wproc.WriteOperationCount),
+            self.convert(wproc.WriteTransferCount)
+          )
+
+          ###############################################################
+          # On Windows XP or later, set the cmdline to the CommandLine
+          # attribute.  Otherwise, set it to the ExecutablePath
+          # attribute.
+          ###############################################################
+          if wproc.WindowsVersion.to_f < 5.1
+            struct.cmdline = wproc.ExecutablePath
+          else
+            struct.cmdline = wproc.CommandLine
+          end
+
+          struct.freeze # This is read-only data
+
+          if block_given?
+            yield struct
+          else
+            array << struct
+          end
+        }
+      end
+
+      pid ? struct : array
+    end
+
+    private
+
+    #######################################################################
+    # Converts a string in the format '20040703074625.015625-360' into a
+    # Ruby Time object.
+    #######################################################################
+    def self.parse_ms_date(str)
+      return if str.nil?
+      return DateTime.parse(str)
+    end
+
+    #####################################################################
+    # There is a bug in win32ole where uint64 types are returned as a
+    # String instead of a Fixnum.  This method deals with that for now.
+    #####################################################################
+    def self.convert(str)
+      return nil if str.nil? # Return nil, not 0
+      return str.to_i
+    end
+  end
+end