sys-proctable 0.9.1-universal-darwin

data/Rakefile

@@ -0,0 +1,173 @@
+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
+
+    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/ext/darwin/extconf.rb

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

data/ext/darwin/sys/proctable.c

@@ -0,0 +1,255 @@
+/**********************************************************************
+ * Mac OS X code for sys-proctable Ruby library.                      *
+ *                                                                    *
+ * Date: 3-Mar-2006 (original submission date)                        *
+ * Author: David Felstead (david.felstead at gmail dot com)           *
+ * Based on bsd.c by Daniel J. Berger (djberg96 at gmail dot com)     *
+ *********************************************************************/
+#include "ruby.h"
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <errno.h>
+
+#define SYS_PROCTABLE_VERSION "0.9.1"
+
+#define PROC_MIB_LEN 4
+#define ARGS_MIB_LEN 3
+#define ARGS_MAX_LEN 4096
+VALUE cProcTableError, sProcStruct;
+
+const char* fields[] = {
+   "pid", "ppid", "pgid", "ruid", "rgid", "comm", "state", "pctcpu", "oncpu",
+   "tnum", "tdev", "wmesg", "rtime", "priority", "usrpri", "nice", "cmdline",
+   "starttime", "maxrss", "ixrss", "idrss", "isrss", "minflt", "majflt",
+   "nswap", "inblock", "oublock", "msgsnd", "msgrcv", "nsignals", "nvcsw",
+   "nivcsw", "utime", "stime"
+};
+
+/*
+ * 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 pt_ps(int argc, VALUE* argv, VALUE klass){
+   int err;
+   char state[8];
+   struct kinfo_proc* procs;
+   VALUE v_pid, v_tty_num, v_tty_dev, v_start_time;
+   VALUE v_pstruct = Qnil;
+   VALUE v_array = rb_ary_new();
+   size_t length, count;
+   size_t i = 0;
+   char args[ARGS_MAX_LEN+1];
+
+   // Passed into sysctl call
+   static const int name_mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
+
+   rb_scan_args(argc, argv, "01", &v_pid);
+
+   // Get size of proc kproc buffer
+   err = sysctl( (int *) name_mib, PROC_MIB_LEN, NULL, &length, NULL, 0);
+
+   if(err == -1)
+      rb_raise(cProcTableError, "sysctl: %s", strerror(errno));
+
+   // Populate the kproc buffer
+   procs = malloc(length);
+
+   if(procs == NULL)
+      rb_raise(cProcTableError, "malloc: %s", strerror(errno));
+
+   err = sysctl( (int *) name_mib, PROC_MIB_LEN, procs, &length, NULL, 0);
+
+   if(err == -1)
+      rb_raise(cProcTableError, "sysctl: %s", strerror(errno));
+
+   // If we're here, we got our list
+   count = length / sizeof(struct kinfo_proc);
+
+   for(i = 0; i < count; i++) {
+      v_tty_num = Qnil;
+      v_tty_dev = Qnil;
+      v_start_time = Qnil;
+
+      // If a PID is provided, skip unless the PID matches
+      if( (!NIL_P(v_pid)) && (procs[i].kp_proc.p_pid != NUM2INT(v_pid)) )
+         continue;
+
+      *args = '\0';
+
+      /* Query the command line args */
+      /* TODO: Cmd line not working for now - fix */
+
+      /*args_mib[ARGS_MIB_LEN - 1] = procs[i].kp_proc.p_pid;
+      args_err = sysctl( (int *) args_mib, ARGS_MIB_LEN, args, &args_size, NULL, 0);
+
+      if(args_err >= 0) {
+         fprintf(stderr, "Ret: %d LEN: %d\n", err, args_size);
+         char *c;
+         for(c = args; c < args+args_size; c++)
+            if(*c == '\0') *c = ' ';
+         args[args_size] = '\0';
+      } else {
+         fprintf(stderr, "err: %s LEN: %d\n", strerror(errno), args_size);
+      }*/
+
+      // Get the start time of the process
+      v_start_time = rb_time_new(
+         procs[i].kp_proc.p_un.__p_starttime.tv_sec,
+         procs[i].kp_proc.p_un.__p_starttime.tv_usec
+      );
+
+      // Get the state of the process
+      switch(procs[i].kp_proc.p_stat)
+      {
+         case SIDL:
+            strcpy(state, "idle");
+            break;
+         case SRUN:
+            strcpy(state, "run");
+            break;
+         case SSLEEP:
+            strcpy(state, "sleep");
+            break;
+         case SSTOP:
+            strcpy(state, "stop");
+            break;
+         case SZOMB:
+            strcpy(state, "zombie");
+            break;
+         default:
+            strcpy(state, "unknown");
+            break;
+      }
+
+      // Get ttynum and ttydev. If ttynum is -1, there is no tty.
+      if(procs[i].kp_eproc.e_tdev != -1){
+         v_tty_num = INT2FIX(procs[i].kp_eproc.e_tdev),
+         v_tty_dev = rb_str_new2(devname(procs[i].kp_eproc.e_tdev, S_IFCHR));
+      }
+
+      v_pstruct = rb_struct_new(
+         sProcStruct,
+         INT2FIX(procs[i].kp_proc.p_pid),
+         INT2FIX(procs[i].kp_eproc.e_ppid),
+         INT2FIX(procs[i].kp_eproc.e_pgid),
+         INT2FIX(procs[i].kp_eproc.e_pcred.p_ruid),
+         INT2FIX(procs[i].kp_eproc.e_pcred.p_rgid),
+         rb_str_new2(procs[i].kp_proc.p_comm),
+         rb_str_new2(state),
+         rb_float_new(procs[i].kp_proc.p_pctcpu),
+         Qnil,
+         v_tty_num,
+         v_tty_dev,
+         rb_str_new2(procs[i].kp_eproc.e_wmesg),
+         INT2FIX(procs[i].kp_proc.p_rtime.tv_sec),
+         INT2FIX(procs[i].kp_proc.p_priority),
+         INT2FIX(procs[i].kp_proc.p_usrpri),
+         INT2FIX(procs[i].kp_proc.p_nice),
+         rb_str_new2(args),
+         v_start_time,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_maxrss) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_ixrss) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_idrss) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_isrss) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_minflt) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_majflt) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nswap) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_inblock) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_oublock) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgsnd) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgrcv) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nsignals) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nvcsw) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nivcsw) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_utime.tv_sec) : Qnil,
+         (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_stime.tv_sec) : Qnil
+      );
+
+      OBJ_FREEZE(v_pstruct); // This is read-only data
+
+      if(rb_block_given_p())
+         rb_yield(v_pstruct);
+      else
+         rb_ary_push(v_array, v_pstruct);
+   }
+
+   if(procs) free(procs);
+
+   if(!rb_block_given_p()){
+      if(NIL_P(v_pid))
+         return v_array;
+      else
+         return v_pstruct;
+   }
+
+   return Qnil;
+}
+
+/*
+ * 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 pt_fields(VALUE klass){
+   VALUE v_array = rb_ary_new();
+   int size = sizeof(fields) / sizeof(fields[0]);
+   int i;
+
+   for(i = 0; i < size; i++)
+      rb_ary_push(v_array, rb_str_new2(fields[i]));
+
+   return v_array;
+}
+
+/*
+ * 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 class typically raised if any of the ProcTable methods fail */
+   cProcTableError = rb_define_class_under(cProcTable, "Error", rb_eStandardError);
+
+   /* Singleton methods */
+
+   rb_define_singleton_method(cProcTable, "ps", pt_ps, -1);
+   rb_define_singleton_method(cProcTable, "fields", pt_fields, 0);
+
+   /* There is no constructor */
+   rb_funcall(cProcTable, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
+
+   /* Constants */
+
+   /* 0.9.1: The version of the sys-proctable library */
+   rb_define_const(cProcTable, "VERSION", rb_str_new2(SYS_PROCTABLE_VERSION));
+
+   /* Structs */
+
+   sProcStruct = rb_struct_define("ProcTableStruct","pid","ppid","pgid","ruid",
+      "rgid","comm","state","pctcpu","oncpu","tnum","tdev","wmesg",
+      "rtime", "priority","usrpri","nice","cmdline","starttime",
+      "maxrss","ixrss","idrss","isrss","minflt","majflt","nswap",
+      "inblock","oublock","msgsnd","msgrcv","nsignals","nvcsw","nivcsw",
+      "utime","stime", NULL
+   );
+}