sys-proctable 0.9.9-universal-hpux

data/Rakefile

@@ -0,0 +1,218 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rbconfig'
+include RbConfig
+
+CLEAN.include(
+  '**/*.core',              # Core dump files
+  '**/*.gem',               # Gem files
+  '**/*.rbc',               # Rubinius
+  '**/*.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
+  if RUBY_PLATFORM == 'java'
+    if ENV['JRUBY_OPTS']
+      ENV['JRUBY_OPTS'] += ' -Xcext.enabled=true'
+    else
+      ENV['JRUBY_OPTS'] = '-Xcext.enabled=true'
+    end
+  end
+
+  case CONFIG['host_os']
+    when /darwin/i
+      dir = 'ext/darwin'
+      ext = '.bundle'
+    when /hpux/i
+      dir = 'ext/hpux'
+      ext = '.sl'
+  end
+
+  if CONFIG['host_os'] =~ /darwin|hpux/i
+    Dir.chdir(dir) do
+      ruby 'extconf.rb'
+      sh 'make'
+      cp 'proctable' + ext, '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 /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
+      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 /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) 
+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 /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 /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 for the specified OS, or your current OS by default'
+  task :create, [:os] => [:clean] do |_task, args|
+    require 'rubygems/package'
+
+    if args.is_a?(String)
+      os = args
+    else
+      args.with_defaults(:os => CONFIG['host_os'])
+      os = args[:os]
+    end
+
+    spec = eval(IO.read('sys-proctable.gemspec'))
+    spec.files += ['lib/sys-proctable.rb']
+
+    # 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 os
+      when /freebsd/i
+         spec.platform = Gem::Platform.new(['universal', 'freebsd'])
+         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'
+         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', 'lib/linux/sys/proctable/cgroup_entry.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 /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']
+         spec.files += ['lib/windows/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_windows.rb'
+      else
+         raise "Unsupported platform: #{os}"
+    end
+
+    spec.test_files << 'test/test_sys_top.rb'
+ 
+    # https://github.com/rubygems/rubygems/issues/147
+    spec.original_platform = spec.platform
+
+    spec.signing_key = File.join(Dir.home, '.ssh', 'gem-private_key.pem')
+
+    Gem::Package.build(spec, true)
+  end
+
+  desc 'Create a gem for each supported OS'
+  task :create_all => [:clean] do
+    platforms = %w[aix darwin freebsd hpux linux solaris windows]
+    Rake::Task["clean"].execute
+    platforms.each{ |os|
+      FileUtils.mkdir_p("pkg/#{os}")
+      Rake::Task["gem:create"].execute(os)
+      Dir.glob("*.gem").each{ |gem| FileUtils.mv(gem, "pkg/#{os}") }
+    }
+  end
+
+  desc 'Install the sys-proctable library as a gem'
+  task :install => [:create] do
+    gem_name = Dir['*.gem'].first
+    sh "gem install -l #{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/ext/hpux/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+have_type('rb_pid_t', 'ruby.h')
+create_makefile('sys/proctable', 'sys')

data/ext/hpux/sys/proctable.c

@@ -0,0 +1,325 @@
+/**********************************************************************
+* proctable.c
+*
+* HP-UX specific code for the Ruby ps extension.  Some code has been
+* copied directly from Dan Urist's Proc::ProcessTable Perl module.
+*
+* Author: Daniel Berger
+**********************************************************************/
+#include "ruby.h"
+
+#define _PSTAT64
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <sys/param.h>
+#include <sys/pstat.h>
+#include <devnm.h>
+
+#define BURST 30 /* pstat structs to get per syscall */
+
+/* Process state strings */
+#define SLEEP  "sleep"
+#define RUN    "run"
+#define STOP   "stop"
+#define ZOMBIE "zombie"
+#define IDLE   "idle"
+#define OTHER  "other"
+
+VALUE sProcStruct, cProcError;
+
+/*****************************************************************************
+ * This array's only purpose is for the 'fields()' class method.  If there's
+ * a way to report fields out of our defined struct (sProc), please tell me
+ * how!
+ *****************************************************************************/
+char *fields[] = {
+   "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"
+};
+
+
+/*
+ * Private method that converts a psinfo struct into a Ruby struct.
+ */
+static VALUE proctable_getprocstruct(struct pst_status *p)
+{
+   char state[10];
+   char flag[12];
+   char ttydev[MAXPATHLEN+1];
+   VALUE v_tty, v_struct;
+
+   switch( p->pst_stat )
+   {
+      case PS_SLEEP:
+         strcpy(state,SLEEP);
+         break;
+      case PS_RUN:
+         strcpy(state,RUN);
+         break;
+      case PS_STOP:
+         strcpy(state,STOP);
+         break;
+      case PS_ZOMBIE:
+         strcpy(state,ZOMBIE);
+         break;
+      case PS_IDLE:
+         strcpy(state,IDLE);
+         break;
+      case PS_OTHER:
+         strcpy(state,OTHER);
+         break;
+      default:
+         strcpy(state,"unknown");
+   }
+
+   /* If the major number is -1, there is no associated tty */
+   if(p->pst_term.psd_major != -1){
+      devnm(
+         S_IFCHR,
+         (dev_t)((p->pst_term.psd_major << 24) | p->pst_term.psd_minor),
+         ttydev,
+         sizeof(ttydev),
+         1
+      );
+      v_tty = rb_str_new2(ttydev);
+   }
+   else{
+      v_tty = rb_str_new2("");
+   }
+
+   v_struct = rb_struct_new(sProcStruct,
+      rb_str_new2(p->pst_ucomm),
+      INT2NUM(p->pst_uid),
+      INT2NUM(p->pst_pid),
+      INT2NUM(p->pst_ppid),
+      INT2NUM(p->pst_dsize),
+      INT2NUM(p->pst_tsize),
+      INT2NUM(p->pst_ssize),
+      INT2NUM(p->pst_nice),
+      v_tty,
+      INT2NUM(p->pst_pgrp),
+      INT2NUM(p->pst_pri),
+      INT2NUM(p->pst_addr),
+      INT2NUM(p->pst_cpu),
+      INT2NUM(p->pst_utime),
+      INT2NUM(p->pst_stime),
+      rb_time_new(p->pst_start,0),
+      INT2NUM(p->pst_flag),
+      rb_str_new2(state),
+      INT2NUM(p->pst_wchan),
+      INT2NUM(p->pst_procnum),
+      rb_str_new2(p->pst_cmd),
+      rb_str_new2(p->pst_cmd),
+      INT2NUM(p->pst_time),
+      INT2NUM(p->pst_cpticks),
+      INT2NUM(p->pst_cptickstotal),
+      INT2NUM(p->pst_fss),
+      rb_float_new(p->pst_pctcpu),
+      INT2NUM(p->pst_rssize),
+      INT2NUM(p->pst_suid),
+      INT2NUM(p->pst_shmsize),
+      INT2NUM(p->pst_mmsize),
+      INT2NUM(p->pst_usize),
+      INT2NUM(p->pst_iosize),
+      INT2NUM(p->pst_vtsize),
+      INT2NUM(p->pst_vdsize),
+      INT2NUM(p->pst_vssize),
+      INT2NUM(p->pst_vshmsize),
+      INT2NUM(p->pst_vmmsize),
+      INT2NUM(p->pst_vusize),
+      INT2NUM(p->pst_viosize),
+      UINT2NUM(p->pst_minorfaults),
+      UINT2NUM(p->pst_majorfaults),
+      UINT2NUM(p->pst_nswap),
+      UINT2NUM(p->pst_nsignals),
+      UINT2NUM(p->pst_msgrcv),
+      UINT2NUM(p->pst_msgsnd),
+      INT2NUM(p->pst_maxrss),
+      INT2NUM(p->pst_sid),
+      INT2NUM(p->pst_schedpolicy),
+      INT2NUM(p->pst_ticksleft),
+      INT2NUM(p->pst_euid),
+      INT2NUM(p->pst_egid),
+      INT2NUM(p->pst_gid),
+      INT2NUM(p->pst_sgid)
+   );
+
+   OBJ_FREEZE(v_struct);
+
+   return v_struct;
+}
+
+/*
+ * 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 proctable_ps(int argc, VALUE *argv)
+{
+   struct pst_status pst[BURST];
+   int i, count;
+   int idx = 0;
+   int found = 0;
+   VALUE v_pid = Qnil;
+   VALUE v_arr = rb_ary_new();
+
+   rb_scan_args(argc, argv, "01", &v_pid);
+
+   if(v_pid != Qnil){
+      struct pst_status pst_single;
+      int n = NUM2INT(v_pid);
+      if(pstat_getproc(&pst_single, sizeof(pst_single), 0, n) > 0){
+         if(rb_block_given_p()){
+            rb_yield(proctable_getprocstruct(&pst_single));
+            return Qnil;
+         }
+         else{
+            return(proctable_getprocstruct(&pst_single));
+         }
+      }
+      else{
+         return Qnil; /* not found */
+      }
+   }
+
+   while ((count = pstat_getproc(pst, sizeof(pst[0]), BURST, idx)) > 0){
+      for (i = 0; i < count; i++){
+         if( rb_block_given_p() )
+            rb_yield(proctable_getprocstruct(&pst[i]));
+         else
+            rb_ary_push(v_arr, proctable_getprocstruct(&pst[i]) );
+      }
+      idx = pst[count-1].pst_idx + 1;
+   }
+
+   if(rb_block_given_p())
+      return Qnil;
+
+   return v_arr;
+}
+
+/*
+ * 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 proctable_fields()
+{
+   int i;
+   VALUE v_farray = rb_ary_new();
+
+   for(i = 0; i < (sizeof(fields) / sizeof(fields[0])); i++)
+      rb_ary_push(v_farray,rb_str_new2(fields[i]));
+
+   return v_farray;
+}
+
+/*
+ * 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 */
+   cProcError = rb_define_class_under(cProcTable, "Error", rb_eStandardError);
+
+   /* Singleton methods */
+
+   rb_define_singleton_method(cProcTable, "fields", proctable_fields, 0);
+   rb_define_singleton_method(cProcTable, "ps", proctable_ps, -1);
+
+   /* There is no constructor */
+   rb_funcall(cProcTable, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
+
+   /* 0.9.9: The version of the sys-proctable library. */
+   rb_define_const(cProcTable, "VERSION", rb_str_new2("0.9.9"));
+
+   /* Structs */
+
+   sProcStruct = rb_struct_define("ProcTableStruct",
+      "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",NULL
+   );
+}
+
+#ifdef __cplusplus
+}
+#endif