sys-proctable 0.9.1-universal-freebsd

data/Rakefile

@@ -0,0 +1,176 @@
+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-freebsd8.0')
+         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-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/ext/bsd/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+have_type('rb_pid_t', 'ruby.h')
+
+have_library('kvm')
+have_func('kvm_openfiles')
+have_struct_member('struct kinfo_proc', 'kp_proc', 'sys/user.h')
+have_struct_member('struct kinfo_proc', 'kp_eproc', 'sys/user.h')
+have_struct_member('struct kinfo_proc', 'u_kproc', 'sys/user.h')
+have_struct_member('struct eproc', 'e_stats', 'sys/sysctl.h')
+have_struct_member('struct eproc', 'p_oncpu', 'sys/sysctl.h')
+have_struct_member('struct eproc', 'p_runtime', 'sys/sysctl.h')          
+
+create_makefile('sys/proctable', 'sys')

data/ext/bsd/sys/proctable.c

@@ -0,0 +1,301 @@
+/**********************************************************************
+ * proctable.c
+ *
+ * This is a generic kvm interface used by the various BSD flavors
+ * for the sys-proctable library.
+ **********************************************************************/
+#include "ruby.h"
+#include <kvm.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <sys/user.h>
+
+#define SYS_PROCTABLE_VERSION "0.9.1"
+
+VALUE cProcTableError, sProcStruct;
+
+const char* fields[] = {
+  "pid", "ppid", "pgid", "ruid",
+  "rgid", "comm", "state", "pctcpu", "oncpu", "ttynum", "ttydev", "wmesg",
+  "time", "priority", "usrpri", "nice", "cmdline", "start",
+  "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){
+  kvm_t *kd;
+  char errbuf[_POSIX2_LINE_MAX];
+  char cmdline[_POSIX_ARG_MAX+1];
+  char state[8];
+  char** args = malloc(sizeof(char*));
+  struct kinfo_proc* procs;
+  int count;                     // Holds total number of processes
+  int i = 0;
+  VALUE v_pid, v_tty_num, v_tty_dev, v_start_time;
+  VALUE v_pstruct = Qnil;
+  VALUE v_array = Qnil;
+
+  rb_scan_args(argc, argv, "01", &v_pid);
+
+  if(!NIL_P(v_pid))
+    Check_Type(v_pid, T_FIXNUM);
+
+  if(!rb_block_given_p())
+    v_array = rb_ary_new();
+
+  // Open the kvm interface, get a descriptor
+  if((kd = kvm_open(NULL, NULL, NULL, 0, "kvm_open")) == NULL)
+    rb_raise(cProcTableError, "kvm_open failed: %s", strerror(errno)); 
+
+  // Get the list of processes
+  if((procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, &count)) == NULL) {
+    strcpy(errbuf, kvm_geterr(kd));
+    kvm_close(kd);
+    rb_raise(cProcTableError, errbuf);
+  }
+
+  for(i=0; i<count; i++){
+    // Reset some variables
+    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)){
+#ifdef HAVE_ST_KP_PROC
+      if(procs[i].kp_proc.p_pid != NUM2INT(v_pid))
+        continue;
+#else
+      if(procs[i].ki_pid != NUM2INT(v_pid))
+        continue;
+#endif
+      }
+
+    // Get the command line arguments for the process
+    cmdline[0] = '\0';
+    args = kvm_getargv(kd, (const struct kinfo_proc *)&procs[i], 0);
+
+    if(args){
+      int j = 0;
+      while (args[j] && strlen(cmdline) <= _POSIX_ARG_MAX) {
+        strcat(cmdline, args[j]);
+        strcat(cmdline, " ");
+        j++;
+       }
+    }
+
+    // Get the start time of the process
+    v_start_time = rb_time_new(
+#ifdef HAVE_ST_E_STATS
+      procs[i].kp_eproc.e_stats.p_start.tv_sec,
+      procs[i].kp_eproc.e_stats.p_start.tv_usec
+#else
+      0,0
+#endif
+    );
+
+    // Get the state of the process
+#ifdef HAVE_ST_KP_PROC
+    switch(procs[i].kp_proc.p_stat)
+#else
+    switch(procs[i].ki_stat)
+#endif
+    {
+      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
+#ifdef HAVE_ST_KP_EPROC
+    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));
+#elif HAVE_ST_U_KPROC
+    v_tty_num = INT2FIX(procs[i].u_kproc.ki_tdev),
+    v_tty_dev = rb_str_new2(devname(procs[i].u_kproc.ki_tdev, S_IFCHR));
+#else
+    v_tty_num = INT2FIX(procs[i].ki_tdev),
+    v_tty_dev = rb_str_new2(devname(procs[i].ki_tdev, S_IFCHR));
+#endif
+
+#ifdef HAVE_ST_KP_PROC
+    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),
+#ifdef HAVE_ST_P_ONCPU
+      INT2FIX(procs[i].kp_proc.p_oncpu),
+#else
+      Qnil,
+#endif
+      v_tty_num,
+      v_tty_dev,
+      rb_str_new2(procs[i].kp_eproc.e_wmesg),
+#ifdef HAVE_ST_P_RUNTIME
+      INT2FIX(procs[i].kp_proc.p_runtime/1000000),
+#else
+      Qnil,
+#endif
+      INT2FIX(procs[i].kp_proc.p_priority),
+      INT2FIX(procs[i].kp_proc.p_usrpri),
+      INT2FIX(procs[i].kp_proc.p_nice),
+      rb_str_new2(cmdline),
+      v_start_time,
+#ifdef HAVE_ST_E_STATS
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_maxrss),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_ixrss),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_idrss),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_isrss),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_minflt),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_majflt),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nswap),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_inblock),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_oublock),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_msgsnd),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_msgrcv),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nsignals),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nvcsw),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nivcsw),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_utime.tv_sec),
+      LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_stime.tv_sec)
+#else
+      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil,
+      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil
+#endif
+    );
+#else
+    v_pstruct = rb_struct_new(
+      sProcStruct,
+      INT2FIX(procs[i].ki_pid),
+      INT2FIX(procs[i].ki_ppid),
+      INT2FIX(procs[i].ki_pgid),
+      INT2FIX(procs[i].ki_ruid),
+      INT2FIX(procs[i].ki_rgid),
+      rb_str_new2(procs[i].ki_ocomm),
+      rb_str_new2(state),
+      rb_float_new(procs[i].ki_pctcpu),
+      INT2FIX(procs[i].ki_oncpu),
+      v_tty_num,
+      v_tty_dev,
+      rb_str_new2(procs[i].ki_wmesg),
+      INT2FIX(procs[i].ki_runtime/1000000),
+      INT2FIX(procs[i].ki_pri.pri_level),
+      INT2FIX(procs[i].ki_pri.pri_user),
+      INT2FIX(procs[i].ki_nice),
+      rb_str_new2(cmdline),
+      v_start_time,
+      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil,
+      Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil
+    );
+#endif
+
+    OBJ_FREEZE(v_pstruct); // Read-only data
+
+    if(rb_block_given_p())
+      rb_yield(v_pstruct);
+    else
+      rb_ary_push(v_array, v_pstruct);
+  }
+
+  if(kd)
+    kvm_close(kd);
+
+  if(!NIL_P(v_pid))
+    return v_pstruct;
+
+  return v_array; // Nil if block given
+}
+
+/*
+ * 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 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));
+
+   /* Structures */
+
+   sProcStruct = rb_struct_define("ProcTableStruct","pid","ppid","pgid","ruid",
+      "rgid","comm","state","pctcpu","oncpu","ttynum","ttydev","wmesg",
+      "time", "priority","usrpri","nice","cmdline","start",
+      "maxrss","ixrss","idrss","isrss","minflt","majflt","nswap",
+      "inblock","oublock","msgsnd","msgrcv","nsignals","nvcsw","nivcsw",
+      "utime","stime", NULL
+   );
+}