sys-proctable 0.7.6-powerpc-darwin

data/doc/hpux.txt

@@ -0,0 +1,77 @@
+= Description
+   sys-proctable
+
+   A Ruby version of the 'ps' command.  This is a C extension, not parsed
+   output.  For HP-UX, proc structs are grabbed via the pstat_getproc() call.
+
+= Synopsis
+   require 'sys/proctable'
+   include Sys
+
+   # Everything
+   ProcTable.ps{ |p|
+      puts p.pid.to_s
+      puts p.comm
+      ...
+   }
+
+   or
+
+   # Return the results as an array of ProcTableStructs
+   a = ProcTable.ps()
+   a.each do |p|
+      puts a.pid
+      ...
+   end
+
+= Constants
+VERSION
+   Returns the current version number for this package (as a string).
+
+= Class Methods
+ProcTable.fields
+   Returns an array of fields available on the current OS.
+
+ProcTable.ps(pid=nil)
+ProcTable.ps{ |s| ... }
+   Returns a struct of type ProcTableStruct for every process in the proc
+   table in block form.  Otherwise it returns an array of ProcTableStruct's.
+
+   If a pid is provided then a single ProcTable struct is returned, or nil
+   if the pid is not found.
+
+= Supported fields
+   You can view the supported fields with the "fields()" class method.
+
+= Future Plans
+   Have the flags field return a meaningful value.
+
+= Notes
+   The "comm" field isn't really part of the psinfo struct.  It is just a copy
+   (i.e. is identical to) the "fname" field.  I added it to provide a degree
+   of consistency between all of the platforms.  I will also make a point
+   of adding it to any future platform releases.
+
+= Known Bugs
+   None that I'm aware of.  Please log any bugs on the project page at
+   http://www.rubyforge.org/projects/sysutils
+
+= License
+   Ruby's
+
+= Copyright
+   (C) 2003-2006 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
+   djberg96 at nospam at gmail dot com
+   imperator on IRC (Freenode)
+
+= See Also
+   ps, proc

data/doc/linux.txt

@@ -0,0 +1,85 @@
+= Description
+   sys-proctable
+
+   A Ruby version of the 'ps' command.  This is a C extension, not parsed
+   output. For Linux, process information is read out of /proc.
+
+= Synopsis
+   require 'sys/proctable'
+   include Sys
+
+   # Everything
+   ProcTable.ps{ |p|
+      puts p.pid.to_s
+      puts p.comm
+      ...
+   }
+
+   or
+
+   # Just one process
+   p = ProcTable.ps(2123)
+   puts p.pid.to_s
+   puts p.comm
+   ...
+
+   or
+
+   # Return the results as an array of ProcTableStructs
+   a = ProcTable.ps()
+   a.each do |p|
+      puts a.pid
+      ...
+   end
+
+= Constants
+VERSION
+   Returns the current version number for this package (as a string).
+
+= Class Methods
+ProcTable.fields
+   Returns an array of fields available on the current OS.
+
+ProcTable.ps(pid=nil)
+ProcTable.ps{ |s| ... }
+   If no pid's or processes are included as arguments, in block form it
+   returns a struct of type ProcTableStruct for every process in the proc
+   table.  Otherwise it returns an array of ProcTableStruct's.
+
+   If a process id is provided, a single ProcTable struct is returned, or
+   nil if the pid is not found.
+
+= Exception Classes
+ProcTableError < StandardError
+   Raised if the /proc field is unreadable and/or unmounted.
+
+= Supported fields
+   You can view the supported fields with the "fields()" class method.
+
+= Future Plans
+   Create a pure Ruby version as an alternative.
+   Change the ttynum field to ttydev and return a string instead of an int.
+
+= Known Bugs
+   None known.  Please log any bugs on the project page at
+   http://www.rubyforge.org/projects/sysutils
+
+= License
+   Ruby's
+
+= Copyright
+   (C) 2003-2006 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
+   djberg96 at nospam at gmail dot com
+   rubyhacker1 on IRC (Freenode)
+
+= See Also
+    ps, proc(5)

data/doc/solaris.txt

@@ -0,0 +1,99 @@
+= Description
+   sys-proctable
+
+   A Ruby version of the 'ps' command.  This is a C extension, not parsed
+   output.  For Solaris, data is read out of /proc via the psinfo struct.
+   
+= Synopsis
+   require 'sys/proctable'
+   include Sys
+
+   # Everything
+   ProcTable.ps{ |p|
+      puts p.pid.to_s
+      puts p.comm
+      ...
+   }
+
+   or
+
+   # Just one process
+   s = ProcTable.ps(2123)
+   puts s.pid.to_s
+   puts s.comm
+   ...
+
+   # Return the results as an array of ProcTableStructs
+   a = ProcTable.ps
+   a.each do |p|
+      puts a.pid
+      ...
+   end
+   
+= Constants
+VERSION
+   Returns the current version number for this package (as a string).
+    
+= Class Methods
+ProcTable.fields
+   Returns an array of fields available on the current OS.
+    
+ProcTable.ps(pid=nil)
+ProcTable.ps{ |s| ... }
+   If no pid is included as an argument, in block form it
+   returns a struct of type ProcTableStruct for every process in the proc
+   table.  Otherwise it returns an array of ProcTable struct's.  If a pid
+   is provided it will return a single ProcTable struct for that pid, or
+   nil if it is not found.
+    
+= Exception Classes
+ProcTableError < StandardError
+   Raised if the /proc directory is unreadable and/or unmounted.
+    
+= Supported fields
+   You can view the supported fields with the "fields()" class method.
+
+= Future Plans
+   Return a more meaningful result for the wchan member (2.6+).
+   Add env info where possible.
+    
+= Notes
+   The "comm" field isn't really part of the psinfo struct.  It is just a copy
+   (i.e. is identical to) the "fname" field.  I added it to provide a degree
+   of consistency between all of the platforms.  I will also make a point
+   of adding it to any future platform releases.
+
+   The cmdline string is limited to 80 characters, except for those processes
+   which you (or your program) own.
+
+   The ttydev field is, for now, an integer.  If there is no associated tty with
+   the process, a -1 is returned.   In the future, this field will be changed to
+   a string (i.e. the actual device name).
+
+   I suppose I *could* add a -lkvm version for Solaris (this is what Dan Urist
+   is now using in Proc::ProcessTable) but I haven't found a compelling reason
+   to do so.  If you think you have one, please let me know.
+    
+= Known Bugs
+   None that I am aware of.  Please log any bugs on the RubyForge project page at
+   http://www.rubyforge.org/projects/sysutils
+
+= License
+   Ruby's
+    
+= Copyright
+   (C) 2003-2006 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
+   djberg96 at nospam at gmail dot com
+   imperator on IRC (Freenode)
+    
+= See Also
+   ps, proc

data/doc/top.txt

@@ -0,0 +1,53 @@
+= 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"
+   include Sys
+
+   Top.top(5).each{ |ps|
+      p ps
+   }
+	
+= Constants
+VERSION
+   Returns the version number of this package as a String.
+	
+= Class Methods
+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.
+
+   I used sort() instead of sort_by() internally to maintain backward
+   compatability with Ruby 1.6.8, which I happen to need.
+	
+= Bugs
+   None that I'm aware of.  Please log bug reports on the project page at
+   http://www.rubyforge.org/projects/sysutils
+	
+= License
+   Ruby's
+	
+= Copyright
+   (C) 2004-2006 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
+   djberg96 at nospam at gmail dot com
+   imperator on IRC (Freenode)

data/doc/windows.txt

@@ -0,0 +1,122 @@
+= Description
+   A Ruby interface for gathering process information.  For MS Windows,
+   the process information is gathered via OLE + WMI, using pure Ruby.
+   
+= Synopsis
+   require 'sys/proctable'
+   include Sys
+
+   # Everything
+   ProcTable.ps{ |p|
+      puts p.pid.to_s
+      puts p.comm
+      ...
+   }
+
+   or
+
+   # A single pid
+   p = ProcTable.ps(1234)
+   puts p.pid.to_s
+   puts p.comm
+   ...
+
+   or
+
+   # Return the results as an array of ProcTableStructs
+   a = ProcTable.ps
+   a.each do |p|
+      puts a.pid
+      ...
+   end
+   
+= Constants
+VERSION
+   Returns the current version number for this package (as a string).
+    
+= Class Methods
+ProcTable.fields
+   Returns an Array of fields available on the current OS in the
+   ProcTableStruct.
+    
+ProcTable.ps(pid=nil, host='localhost')
+ProcTable.ps{ |s| ... }
+   Returns a struct of type ProcTableStruct for every process in the proc
+   table in block form.  Otherwise it returns an array of ProcTableStruct's.
+
+   If 'pid' is provided, then only a struct for that pid is returned, or
+   nil if it is not found.
+ 
+   If 'host' is provided, then processes from that host are gathered.  By
+   default, process information is gathered on the local host.
+	 	
+= Supported fields
+   The currently supported fields for MS Windows (i.e. your ProcTable struct
+   members) are:
+    
+    caption, cmdline, comm, creation_class_name, creation_date,
+    cs_creation_class_name, cs_name, description, executable_path,
+    execution_state, handle, handle_count, install_date, kernel_mode_time,
+    maximum_working_set_size, minimum_working_set_size, name,
+    os_creation_class_name, os_name, other_operation_count,
+    other_transfer_count, page_faults, page_file_usage, peak_virtual_size,
+    ppid, peak_working_set_size, priority, private_page_count, pid,
+    quota_non_paged_pool_usage, quota_paged_pool_usage,
+    quota_peak_non_paged_pool_usage, quota_non_paged_pool_usage,
+    read_operation_count, read_transfer_count, session_id,
+    termination_date, thread_count, user_mode_time, virtual_size,
+    windows_version, working_set_size, write_operation_count,
+    write_transfer_count
+
+    You can also view them with the fields() class method.
+    
+= Notes
+   For the sake of attempting to provide a somewhat common API, the 'comm'
+   and 'cmdline' fields have been included as part of the structure.  The
+   'comm' member corresponds to the Name attribute of Win32_Process.  The
+   'cmdline' attribute corresponds to either the Executable_Path attribute
+   (on Windows 2000 or earlier) or the CommandLine attribute (on Windows XP
+   and later).
+	 
+   Also note that the ProcessId and ParentProcessId attributes have been
+   abbreviated as 'pid' and 'ppid' in the struct members, again to keep the
+   members more consistent between platforms.
+	 
+   The "Mem Usage" and "VM Size" that you may be used to seeing in your Task
+   Manager window (probably) correspond to the 'working_set_size' and
+   'page_file_usage' struct members, respectively, keeping in mind that
+   those values are in bytes, not kilobytes.  I say 'probably' because
+   comments that I've read online indicate that it may not always line up
+   with what you see in the Task Manager, based on the current version (or
+   even Service Pack) of Windows that you are using.
+	 
+= Future Plans
+   Possibly use the Win32_PerfFormattedData_PerfProc_Process class to get
+   additional process information.
+    
+= Known Bugs
+   Versions of Ruby earlier than 1.8.2 resulted in segfaults when trying to
+   run this code.  You will likely encounter the same behavior.
+
+   Please log any additional bug reports on the project page at
+   http://www.rubyforge.org/projects/sysutils
+	
+= License
+   Ruby's
+    
+= Copyright
+   (C) 2003-2006 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
+   djberg96 at nospam at gmail dot com
+   imperator on IRC (freenode)
+    
+= See Also
+   OLE + WMI

data/ext/darwin/darwin.c

@@ -0,0 +1,240 @@
+/* Mac OS X code for Ruby Sys::ProcTable                          */
+/* 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 "version.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 PROC_MIB_LEN 4
+#define ARGS_MIB_LEN 3
+#define ARGS_MAX_LEN 4096
+VALUE cProcTableError, sProcStruct;
+
+char* fields[] = {
+   "pid","ppid","pgid","ruid",
+   "rgid","comm","state","pctcpu","cpu_num","tty_num","tty_dev","wchan",
+   "time", "priority","usr_priority","nice","cmdline","start_time",
+   "max_rss","ix_rss","id_rss","is_rss","minflt","maxflt","nswap",
+   "inblock","oublock","msgsnd","msgrcv","nsignals","nvcsw","nivcsw",
+   "user_time","system_time"
+};
+
+/*
+ * 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);
+
+   /* TODO: Get error message from errno */
+   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);
+
+   /* TODO: Get error message from errno */
+   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++) {
+
+      /* 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)) && (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, //INT2FIX(procs[i].kp_proc.p_oncpu),
+         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,
+         /* For some processes, p_ru is NULL */
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_maxrss)        : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_ixrss)         : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_idrss)         : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_isrss)         : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_minflt)        : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_majflt)        : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nswap)         : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_inblock)       : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_oublock)       : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgsnd)        : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgrcv)        : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nsignals)      : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nvcsw)         : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nivcsw)        : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_utime.tv_sec)  : Qnil,
+         procs[i].kp_proc.p_ru ? LONG2NUM(procs[i].kp_proc.p_ru->ru_stime.tv_sec)  : Qnil
+      );
+
+      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;
+
+   /* Classes and Modules */
+   mSys = rb_define_module("Sys");
+   cProcTable = rb_define_class_under(mSys, "ProcTable", rb_cObject);
+   cProcTableError = rb_define_class_under(mSys, "ProcTableError", rb_eStandardError);
+
+   /* Class Methods */
+   rb_define_singleton_method(cProcTable, "ps", pt_ps, -1);
+   rb_define_singleton_method(cProcTable, "fields", pt_fields, 0);
+
+   /* Constants */
+   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","cpu_num","tty_num","tty_dev","wchan",
+      "time", "priority","usr_priority","nice","cmdline","start_time",
+      "max_rss","ix_rss","id_rss","is_rss","minflt","maxflt","nswap",
+      "inblock","oublock","msgsnd","msgrcv","nsignals","nvcsw","nivcsw",
+      "user_time","system_time", NULL
+   );
+}