tddium-sys-proctable 0.9.2-x86-darwin-10

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,256 @@
+/**********************************************************************
+ * 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;
+   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 = rb_ary_new();
+   size_t length;
+   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, strerror(errno));
+
+   // Populate the kproc buffer
+   procs = malloc(length);
+
+   if(procs == NULL)
+      rb_raise(cProcTableError, strerror(errno));
+
+   err = sysctl( (int *) name_mib, PROC_MIB_LEN, procs, &length, NULL, 0);
+
+   if(err == -1)
+      rb_raise(cProcTableError, 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
+   );
+}

data/lib/sys/top.rb

@@ -0,0 +1,32 @@
+require 'sys/proctable'
+require 'rbconfig'
+
+# 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)
+
+      windows = /mswin|win32|windows|dos|cygwin|mingw/i
+
+      # Sort by pid on Windows by default
+      if Config::CONFIG['host_os'].match(windows) && field == 'pctcpu'
+        field = 'pid'
+      end
+
+      Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+    end
+  end
+end

data/sys-proctable.gemspec

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rbconfig'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'tddium-sys-proctable'
+  spec.version    = '0.9.2'
+  spec.author     = 'Daniel J. Berger'
+  spec.license    = 'Artistic 2.0' 
+  spec.email      = 'info@tddium.com'
+  spec.homepage   = 'http://www.rubyforge.org/projects/sysutils'
+  spec.platform   = Gem::Platform::CURRENT
+  spec.summary    = 'An interface for providing process table information'
+  spec.has_rdoc   = true
+  spec.test_files = ['test/test_sys_proctable_all.rb']
+   
+  # Additional files for your platform are added by the 'rake gem' task.
+  spec.files = [
+    'benchmarks/bench_ps.rb',
+    'examples/example_ps.rb',
+    'lib/sys/top.rb',
+    'CHANGES',
+    'MANIFEST',
+    'Rakefile',
+    'README',
+    'sys-proctable.gemspec'
+  ]
+
+  spec.rubyforge_project = 'sysutils'
+  spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST', 'doc/top.txt']
+
+  spec.add_development_dependency('test-unit', '>= 2.1.2')
+
+  spec.description = <<-EOF
+    Testing a separate publish to see if I can get the mac install to work with bundler.
+
+    The sys-proctable library provides an interface for gathering information
+    about processes on your system, i.e. the process table. Most major
+    platforms are supported and, while different platforms may return
+    different information, the external interface is identical across
+    platforms.
+  EOF
+end

data/test/test_sys_proctable_all.rb

@@ -0,0 +1,85 @@
+#######################################################################
+# test_sys_proctable_all.rb
+#
+# Test suite for methods common to all platforms. Generally speaking
+# you should run this test case using the 'rake test' task.
+#######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'sys/proctable'
+require 'rbconfig'
+require 'test/test_sys_top'
+include Sys
+
+class TC_ProcTable_All < Test::Unit::TestCase
+  def self.startup
+    @@windows = Config::CONFIG['host_os'] =~ /windows|win32|msdos|mswin32|mingw|cygwin/i
+  end
+
+  def setup
+    @pid = @@windows ? 0 : 1
+  end
+
+  def test_version
+    assert_equal('0.9.1', ProcTable::VERSION)
+  end
+
+  def test_fields
+    assert_respond_to(ProcTable, :fields)
+    assert_nothing_raised{ ProcTable.fields }
+    assert_kind_of(Array, ProcTable.fields)
+    assert_kind_of(String, ProcTable.fields.first)
+  end
+
+  def test_ps
+    assert_respond_to(ProcTable, :ps)
+    assert_nothing_raised{ ProcTable.ps }
+    assert_nothing_raised{ ProcTable.ps{} }
+  end
+
+  def test_ps_with_pid
+    assert_nothing_raised{ ProcTable.ps(0) }
+  end
+
+  def test_ps_with_explicit_nil
+    assert_nothing_raised{ ProcTable.ps(nil) }
+    assert_kind_of(Array, ProcTable.ps(nil))
+  end
+
+  def test_ps_return_value
+    assert_kind_of(Array, ProcTable.ps)
+    assert_kind_of(Struct::ProcTableStruct, ProcTable.ps(@pid))
+    assert_equal(nil, ProcTable.ps(999999999))
+    assert_equal(nil, ProcTable.ps(999999999){})
+    assert_equal(nil, ProcTable.ps{})
+  end
+
+  def test_ps_returned_struct_is_frozen
+    assert_true(ProcTable.ps.first.frozen?)
+  end
+
+  def test_ps_expected_errors
+    assert_raises(TypeError){ ProcTable.ps('vim') }
+    omit_if(@@windows, 'ArgumentError check skipped on MS Windows')
+    assert_raises(ArgumentError){ ProcTable.ps(0, 'localhost') }
+  end
+
+  def test_new_not_allowed
+    assert_raise(NoMethodError){ Sys::ProcTable.new }
+  end
+
+  def test_error_class_defined
+    assert_not_nil(Sys::ProcTable::Error)
+    assert_kind_of(StandardError, Sys::ProcTable::Error.new)
+  end
+
+  def teardown
+    @pid  = nil
+  end
+
+  def self.teardown
+    @@windows = nil
+  end
+end