sys-proctable 0.9.1-universal-linux

data/Rakefile

@@ -0,0 +1,175 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rbconfig'
+include Config
+
+CLEAN.include(
+  '**/*.core',              # Core dump files
+  '**/*.gem',               # Gem files
+  '**/*.rbc',               # 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::CONFIG['host_os']
+    when /bsd/i
+      dir = 'ext/bsd'
+    when /darwin/i
+      dir = 'ext/darwin'
+    when /hpux/i
+      dir = 'ext/hpux'
+  end
+
+  unless Config::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::CONFIG['DLEXT'], 'sys'
+    end
+  end
+end
+
+desc 'Install the sys-proctable library'
+task :install => [:build] do
+  file = nil
+  dir  = File.join(Config::CONFIG['sitelibdir'], 'sys')
+
+  Dir.mkdir(dir) unless File.exists?(dir)
+
+  case Config::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::CONFIG['host_os']
+    when /win32|mswin|dos|cygwin|mingw|windows|linux|sunos|solaris/i
+      dir  = File.join(Config::CONFIG['sitelibdir'], 'sys')
+      file = File.join(dir, 'proctable.rb')
+    else
+      dir  = File.join(Config::CONFIG['sitearchdir'], 'sys')
+      file = File.join(dir, 'proctable.' + Config::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::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::CONFIG['host_os']
+      when /bsd/i
+         spec.platform = Gem::Platform.new('universal-bsd')
+         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-solaris10.0')
+         spec.platform.version = nil
+         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::CURRENT
+         spec.platform.cpu = 'universal'
+         spec.platform.version = nil
+         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/linux/sys/proctable.rb

@@ -0,0 +1,281 @@
+# The Sys module serves as a namespace only.
+module Sys
+
+  # The ProcTable class encapsulates process table information.
+  class ProcTable
+
+    # Error typically raised if the ProcTable.ps method fails.
+    class Error < StandardError; end
+
+    # There is no constructor
+    private_class_method :new
+
+    # The version of the sys-proctable library
+    VERSION = '0.9.1'
+
+    private
+
+    @mem_total = IO.read("/proc/meminfo")[/MemTotal.*/].split[1].to_i * 1024 rescue nil
+    @boot_time = IO.read("/proc/stat")[/btime.*/].split.last.to_i rescue nil
+
+    @fields = [
+      'cmdline',     # Complete command line
+      'cwd',         # Current working directory
+      'environ',     # Environment
+      'exe',         # Actual pathname of the executed command
+      'fd',          # File descriptors open by process
+      'root',        # Root directory of process
+      'pid',         # Process ID
+      'comm',        # Filename of executable
+      'state',       # Single character state abbreviation
+      'ppid',        # Parent process ID
+      'pgrp',        # Process group
+      'session',     # Session ID
+      'tty_nr',      # TTY (terminal) associated with the process
+      'tpgid',       # Group ID of the TTY
+      'flags',       # Kernel flags
+      'minflt',      # Number of minor faults
+      'cminflt',     # Number of minor faults of waited-for children
+      'majflt',      # Number of major faults
+      'cmajflt',     # Number of major faults of waited-for children
+      'utime',       # Number of user mode jiffies
+      'stime',       # Number of kernel mode jiffies
+      'cutime',      # Number of children's user mode jiffies
+      'cstime',      # Number of children's kernel mode jiffies
+      'priority',    # Nice value plus 15
+      'nice',        # Nice value
+      'itrealvalue', # Time in jiffies before next SIGALRM
+      'starttime',   # Time in jiffies since system boot
+      'vsize',       # Virtual memory size in bytes
+      'rss',         # Resident set size
+      'rlim',        # Current limit on the rss in bytes
+      'startcode',   # Address above which program text can run
+      'endcode',     # Address below which program text can run
+      'startstack',  # Address of the startstack
+      'kstkesp',     # Kernel stack page address
+      'kstkeip',     # Kernel instruction pointer
+      'signal',      # Bitmap of pending signals
+      'blocked',     # Bitmap of blocked signals
+      'sigignore',   # Bitmap of ignored signals
+      'sigcatch',    # Bitmap of caught signals
+      'wchan',       # Channel in which the process is waiting
+      'nswap',       # Number of pages swapped
+      'cnswap',      # Cumulative nswap for child processes
+      'exit_signal', # Signal to be sent to parent when process dies
+      'processor',   # CPU number last executed on
+      'rt_priority', # Real time scheduling priority
+      'policy',      # Scheduling policy
+      'name',        # Process name
+      'uid',         # Real user ID
+      'euid',        # Effective user ID
+      'gid',         # Real group ID
+      'egid',        # Effective group ID
+      'pctcpu',     # Percent of CPU usage (custom field)
+      'pctmem'      # Percent of Memory usage (custom field)
+    ]
+
+    public
+
+    ProcTableStruct = Struct.new('ProcTableStruct', *@fields)
+
+    # 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)
+    #
+    #--
+    #  It's possible that a process could terminate while gathering
+    #  information for that process. When that happens, this library
+    #  will simply skip to the next record. In short, this library will
+    #  either return all information for a process, or none at all.
+    #
+    def self.ps(pid=nil)
+      array  = block_given? ? nil : []
+      struct = nil
+
+      raise TypeError unless pid.is_a?(Fixnum) if pid
+
+      Dir.foreach("/proc"){ |file|
+        next if file =~ /\D/ # Skip non-numeric directories
+        next unless file.to_i == pid if pid
+
+        struct = ProcTableStruct.new
+
+        # Get /proc/<pid>/cmdline information. Strip out embedded nulls.
+        begin
+          data = IO.read("/proc/#{file}/cmdline").tr("\000", ' ').strip
+          struct.cmdline = data
+        rescue
+          next # Process terminated, on to the next process
+        end
+
+        # Get /proc/<pid>/cwd information
+        struct.cwd = File.readlink("/proc/#{file}/cwd") rescue nil
+
+        # Get /proc/<pid>/environ information. Environment information
+        # is represented as a Hash, with the environment variable as the
+        # key and its value as the hash value.
+        struct.environ = {}
+
+        begin
+          IO.read("/proc/#{file}/environ").split("\0").each{ |str|
+            key, value = str.split('=')
+            struct.environ[key] = value
+          }
+        rescue Errno::EACCES, Errno::ESRCH
+          # Ignore and move on.
+        end
+
+        # Get /proc/<pid>/exe information
+        struct.exe = File.readlink("/proc/#{file}/exe") rescue nil
+
+        # Get /proc/<pid>/fd information. File descriptor information
+        # is represented as a Hash, with the fd as the key, and its
+        # symlink as the value.
+        struct.fd = {}
+
+        begin
+          Dir["/proc/#{file}/fd/*"].each do |fd|
+            struct.fd[File.basename(fd)] = File.readlink(fd) rescue nil
+          end
+        rescue
+          # Ignore and move on
+        end
+
+        # Get /proc/<pid>/root information
+        struct.root = File.readlink("/proc/#{file}/root") rescue nil
+
+        # Get /proc/<pid>/stat information
+        stat = IO.read("/proc/#{file}/stat") rescue next
+
+        # Deal with spaces in comm name. Courtesy of Ara Howard.
+        re = %r/\([^\)]+\)/
+        comm = stat[re]
+        comm.tr!(' ', '-')
+        stat[re] = comm
+
+        stat = stat.split
+
+        struct.pid         = stat[0].to_i
+        struct.comm        = stat[1].tr('()','') # Remove parens
+        struct.state       = stat[2]
+        struct.ppid        = stat[3].to_i
+        struct.pgrp        = stat[4].to_i
+        struct.session     = stat[5].to_i
+        struct.tty_nr      = stat[6].to_i
+        struct.tpgid       = stat[7].to_i
+        struct.flags       = stat[8].to_i
+        struct.minflt      = stat[9].to_i
+        struct.cminflt     = stat[10].to_i
+        struct.majflt      = stat[11].to_i
+        struct.cmajflt     = stat[12].to_i
+        struct.utime       = stat[13].to_i
+        struct.stime       = stat[14].to_i
+        struct.cutime      = stat[15].to_i
+        struct.cstime      = stat[16].to_i
+        struct.priority    = stat[17].to_i
+        struct.nice        = stat[18].to_i
+        # Skip 19
+        struct.itrealvalue = stat[20].to_i
+        struct.starttime   = stat[21].to_i
+        struct.vsize       = stat[22].to_i
+        struct.rss         = stat[23].to_i
+        struct.rlim        = stat[24].to_i
+        struct.startcode   = stat[25].to_i
+        struct.endcode     = stat[26].to_i
+        struct.startstack  = stat[27].to_i
+        struct.kstkesp     = stat[28].to_i
+        struct.kstkeip     = stat[29].to_i
+        struct.signal      = stat[30].to_i
+        struct.blocked     = stat[31].to_i
+        struct.sigignore   = stat[32].to_i
+        struct.sigcatch    = stat[33].to_i
+        struct.wchan       = stat[34].to_i
+        struct.nswap       = stat[35].to_i
+        struct.cnswap      = stat[36].to_i
+        struct.exit_signal = stat[37].to_i
+        struct.processor   = stat[38].to_i
+        struct.rt_priority = stat[39].to_i
+        struct.policy      = stat[40].to_i
+
+        # Get /proc/<pid>/status information (name, uid, euid, gid, egid)
+        IO.foreach("/proc/#{file}/status") do |line|
+          case line
+            when /Name:\s*?(\w+)/
+              struct.name = $1
+            when /Uid:\s*?(\d+)\s*?(\d+)/
+              struct.uid  = $1.to_i
+              struct.euid = $2.to_i
+            when /Gid:\s*?(\d+)\s*?(\d+)/
+              struct.gid  = $1.to_i
+              struct.egid = $2.to_i
+          end
+        end
+
+        # If cmdline is empty use comm instead
+        struct.cmdline = struct.comm if struct.cmdline.empty?
+
+        # Manually calculate CPU and memory usage
+        struct.pctcpu = get_pctcpu(struct.utime, struct.starttime)
+        struct.pctmem = get_pctmem(struct.rss)
+
+        struct.freeze # This is read-only data
+
+        if block_given?
+          yield struct
+        else
+          array << struct
+        end
+      }
+
+      pid ? struct : array
+    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
+
+    # Calculate the percentage of memory usage for the given process.
+    #
+    def self.get_pctmem(rss)
+      return nil unless @mem_total
+      page_size = 4096
+      rss_total = rss * page_size
+      sprintf("%3.2f", (rss_total.to_f / @mem_total) * 100).to_f
+    end
+
+    # Calculate the percentage of CPU usage for the given process.
+    #
+    def self.get_pctcpu(utime, start_time)
+      return nil unless @boot_time
+      hertz = 100.0
+      utime = (utime * 10000).to_f
+      stime = (start_time.to_f / hertz) + @boot_time
+      sprintf("%3.2f", (utime / 10000.0) / (Time.now.to_i - stime)).to_f
+    end
+  end
+end