sys-proctable 0.7.3 → 0.7.4

data/test/test_memleak.rb

@@ -12,12 +12,12 @@ end
 
 base = File.basename(Dir.pwd)
 if base == "test" || base =~ /^sys-proctable.*/
-   require "ftools"
+   require "fileutils"
    Dir.chdir("..") if base == "test"
    $LOAD_PATH.unshift(Dir.pwd)
    File.delete("sys/proctable.so") rescue nil
    Dir.mkdir("sys") rescue nil
-   File.copy("proctable.so","sys")
+   FileUtils.cp("ext/proctable.so", "sys")
 end
 
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: sys-proctable
 version: !ruby/object:Gem::Version 
-  version: 0.7.3
-date: 2006-08-01 00:00:00 -06:00
+  version: 0.7.4
+date: 2006-11-21 00:00:00 -07:00
 summary: An interface for providing process table information
 require_paths: 
 - lib
@@ -30,38 +30,43 @@ authors:
 - Daniel J. Berger
 files: 
 - doc/freebsd.txt
-- doc/top.txt
-- doc/solaris.txt
-- doc/windows.txt
 - doc/hpux.txt
 - doc/linux.txt
+- doc/solaris.txt
+- doc/top.txt
+- doc/windows.txt
+- test/tc_all.rb
+- test/tc_freebsd.rb
+- test/tc_hpux.rb
+- test/tc_kvm_bsd.rb
 - test/tc_linux.rb
 - test/tc_sunos.rb
-- test/tc_kvm_bsd.rb
-- test/tc_hpux.rb
+- test/tc_top.rb
 - test/tc_windows.rb
-- test/test.rb
 - test/test_memleak.rb
-- test/tc_all.rb
-- test/tc_freebsd.rb
-- test/tc_top.rb
+- lib/sys/top.rb
 - CHANGES
 - README
-- extconf.rb
-- lib/version.h
-- lib/os/linux.c
-- lib/os/linux.h
-test_files: []
-
+- MANIFEST
+- ext/sunos/sunos.c
+- ext/extconf.rb
+- ext/version.h
+- ext/sunos/sunos.h
+test_files: 
+- test/tc_sunos.rb
 rdoc_options: []
 
 extra_rdoc_files: 
 - CHANGES
 - README
+- MANIFEST
+- doc/top.txt
+- doc/solaris.txt
+- ext/sunos/sunos.c
 executables: []
 
 extensions: 
-- extconf.rb
+- ext/extconf.rb
 requirements: []
 
 dependencies: []

data/extconf.rb

@@ -1,104 +0,0 @@
-#############################################################################
-# Installation script for sys-proctable.
-#
-# By running this file, it is assumed that you want a C extension, and not
-# a pure Ruby version.  If you want a pure Ruby version (and you're on a 
-# platform for which it's supported), run install.rb instead.
-#############################################################################
-require "mkmf"
-require "ftools"
-
-c_file  = nil
-h_file  = nil
-tc_file = nil
-lib_dir = "lib/os"
-
-########################################################################
-# Ruby 1.8.3 and later mandates the use of rb_pid_t over pid_t because
-# some libraries define their own pid_t.  So, we check for that.
-########################################################################
-have_type("rb_pid_t", "ruby.h")
-
-##########################################################################
-# Determine appropriate source files based on platform.  Also, check for
-# certain header files and/or libraries on some platforms.
-#
-# On FreeBSD a different source file is used if the /proc filesystem is
-# not found (kvm is used instead).  For OpenBSD or NetBSD, the kvm
-# interface is always used for now.
-##########################################################################
-case RUBY_PLATFORM
-   when /hpux/i
-      c_file  = "#{lib_dir}/hpux.c"
-      h_file  = "#{lib_dir}/hpux.h"
-      tc_file = "test/tc_hpux"
-   when /freebsd/i
-      if File.exists?("/proc") && Dir["/proc/*"].length > 0
-         c_file  = "#{lib_dir}/freebsd.c"
-         h_file  = "#{lib_dir}/freebsd.h"
-         tc_file = "test/tc_freebsd"
-      else
-         have_library("kvm")
-         have_struct_member("struct kinfo_proc", "kp_proc", "sys/user.h")
-         have_struct_member("struct kinfo_proc", "kp_eproc", "sys/user.h")
-         c_file  = "#{lib_dir}/bsd.c"
-         tc_file = "test/tc_kvm_bsd.rb"
-      end
-   when /openbsd|netbsd/
-      have_library("kvm")
-      c_file  = "#{lib_dir}/bsd.c"
-      tc_file = "test/tc_kvm_bsd.rb"
-   when /solaris|sunos/i
-      c_file  = "#{lib_dir}/sunos.c"
-      h_file  = "#{lib_dir}/sunos.h"
-      tc_file = "test/tc_sunos"
-      have_header('procfs.h') # false means Solaris 2.5.x
-   when /linux/i
-      c_file  = "#{lib_dir}/linux.c"
-      h_file  = "#{lib_dir}/linux.h"
-      tc_file = "test/tc_linux"
-   when /darwin/i
-      c_file = "#{lib_dir}/darwin.c"
-      tc_file = "test/tc_darwin.rb"
-   when /windows|win32|cygwin|mingw|dos/i
-      msg = "Use the install_pure_ruby.rb script to install on MS Windows"
-      STDERR.puts msg
-      exit
-   else
-      puts "This platform not currently supported.  Exiting..."
-      exit
-end
-
-########################################################################
-# Move any ".rb" files under 'lib/os/' to ".orig" to prevent mkmf from
-# installing them during the 'make site-install' phase.
-########################################################################
-Dir["lib/os/*.rb"].each{ |f|
-   File.rename(f,"lib/os/" + File.basename(f,".rb")+".orig")
-}
-
-################
-# build test.rb
-################
-test_file = "test.rb"
-File.open(test_file,"w+"){ |fh|
-   fh.puts "$LOAD_PATH.unshift Dir.pwd"
-   fh.puts "require \"test/tc_all\""
-   fh.puts "require \"#{tc_file}\""
-   fh.puts "require \"test/tc_top\""
-}
-
-########################################################################
-# Copy or link files to current directory for create_makefile to work.
-######################################################################## 
-File.delete("proctable.c") if File.exists?("proctable.c")
-File.delete("version.h") if File.exists?("version.h")
-if h_file && File.exists?(File.basename(h_file))
-   File.delete(File.basename(h_file))
-end
-	
-File.symlink(c_file,"proctable.c")
-File.symlink(h_file,File.basename(h_file)) unless h_file.nil?
-File.symlink("lib/version.h","version.h")
-
-create_makefile("sys/proctable")

data/lib/os/linux.c

@@ -1,315 +0,0 @@
-/***************************************************************
- * linux.c (proctable.c)
- *
- * Linux specific code for the Ruby ps extension.  Some code
- * has been copied directly from Dan Urist's Proc::ProcessTable
- * Perl module.
- *
- * Author: Daniel J. Berger
- **************************************************************/
-#include "ruby.h"
-#include "linux.h"
-#include "version.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-VALUE sProc, cProcError;
-
-/* 
- * Converts a proc_info struct into a Ruby struct.
- */
-static VALUE proctable_get_process(struct proc_info *p, VALUE env_hash) {
-   return rb_struct_new(sProc,
-      rb_str_new2(p->cmdline),
-      rb_str_new2(p->cwd),
-      rb_str_new2(p->exe),
-      INT2FIX(p->pid),
-      rb_str_new2(p->name),
-      INT2FIX(p->uid),
-      INT2FIX(p->euid),
-      INT2FIX(p->gid),
-      INT2FIX(p->egid),
-      rb_str_new2(p->comm),
-      rb_str_new(p->state,1),
-      INT2FIX(p->ppid),
-      INT2FIX(p->pgrp),
-      INT2FIX(p->session),
-      INT2FIX(p->tty_num),
-      INT2FIX(p->tpgid),
-      UINT2NUM(p->flags),
-      UINT2NUM(p->minflt),
-      UINT2NUM(p->cminflt),
-      UINT2NUM(p->majflt),
-      UINT2NUM(p->cmajflt),
-      INT2FIX(p->utime),
-      INT2FIX(p->stime),
-      INT2FIX(p->cutime),
-      INT2FIX(p->cstime),
-      INT2FIX(p->priority),
-      INT2FIX(p->nice),
-      UINT2NUM(p->itrealvalue),
-      INT2FIX(p->starttime),
-      UINT2NUM(p->vsize),
-      INT2FIX(p->rss),
-      UINT2NUM(p->rlim),
-      UINT2NUM(p->startcode),
-      UINT2NUM(p->endcode),
-      UINT2NUM(p->startstack),
-      UINT2NUM(p->kstkesp),
-      UINT2NUM(p->kstkeip),
-      UINT2NUM(p->signal),
-      UINT2NUM(p->blocked),
-      UINT2NUM(p->sigignore),
-      UINT2NUM(p->sigcatch),
-      UINT2NUM(p->wchan),
-      UINT2NUM(p->nswap),
-      UINT2NUM(p->cnswap),
-      INT2FIX(p->exit_signal),
-      INT2FIX(p->processor),
-      env_hash
-   );
-}
-
-/*
- * 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, VALUE klass){
-   DIR* dir_ptr;
-   FILE* file_ptr;
-   struct dirent* dirent_ptr;
-   struct proc_info p;
-   char pathbuf[NAME_MAX];
-   int temp;
-   int pid = -1;
-
-   VALUE v_pid     = Qnil;
-   VALUE v_array   = Qnil;
-   VALUE v_pstruct = Qnil;
-   VALUE v_env     = rb_hash_new();
-
-   rb_scan_args(argc, argv, "01", &v_pid);
-
-   if((dir_ptr = opendir("/proc")) == NULL)
-      rb_raise(cProcError,"/proc filesystem unreadable");
-   
-   if(!NIL_P(v_pid))
-      pid = NUM2INT(v_pid);
-      
-   if(!rb_block_given_p())
-      v_array = rb_ary_new();
-
-   /* Iterate through all the (numeric) process entries uner /proc */
-   while((dirent_ptr = readdir(dir_ptr)) != NULL){
-
-      /* Only look at this file if it's a proc id; that is, all numbers */
-      if( strtok(dirent_ptr->d_name, "0123456789") != NULL ) {
-         continue;
-      }
-
-      if(!NIL_P(v_pid)){
-         if(atoi(dirent_ptr->d_name) != pid){
-            continue;
-         }
-      }
-
-      /* Get the /proc/PID/cmdline info */
-      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/cmdline");
-      if( (file_ptr = fopen(pathbuf, "r")) != NULL ){
-         size_t got;
-         if((got = fread(p.cmdline, sizeof(char), ARG_MAX, file_ptr)) > 0 ){
-            size_t i;
-            
-            /* Replace \0 characters with spaces */
-            for(i = 0; i < got; i++){
-               if(p.cmdline[i] == '\0'){
-                  p.cmdline[i] = ' ';
-               }
-            }
-            
-            p.cmdline[got] = '\0';
-            trimr(p.cmdline);       /* Trim trailing whitespace */
-         }
-         fclose(file_ptr);
-      }
-
-      /* Get the /proc/PID/exe info (which is a link) */
-      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/exe");
-      memset(p.exe, 0, sizeof(p.exe));
-      readlink(pathbuf, p.exe, sizeof(p.exe));
-
-      /* Get the /proc/PID/cwd info (which is a link) */
-      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/cwd");
-      memset(p.cwd, 0, sizeof(p.cwd));
-      readlink(pathbuf, p.cwd, sizeof(p.cwd));
-
-      /* Get name, uid, euid, gid and gid info out of /proc/PID/status */
-      sprintf(pathbuf,"%s%s%s","/proc/",dirent_ptr->d_name,"/status");
-      if((file_ptr = fopen(pathbuf,"r")) != NULL ){
-         char line[ARG_MAX];
-         char dummy[ARG_MAX];
-
-         while(fgets(line, ARG_MAX - 1, file_ptr) != NULL){ 
-            if(!strncmp("Name", line, strlen("Name"))) { 
-               sscanf(line, "%s %s", dummy, p.name);
-            }
-            else if(!strncmp("Uid", line, strlen("Uid"))){ 
-               sscanf(line, "%s %d %d", dummy, &p.uid, &p.euid);
-            }
-            else if (!strncmp("Gid", line, strlen("Gid"))) { 
-               sscanf(line, "%s %d %d", dummy, &p.gid, &p.egid);
-            }
-         }
-         fclose(file_ptr);
-      }
-
-      /* Get the /proc/PID/stat info */
-      sprintf(pathbuf,"%s%s%s","/proc/",dirent_ptr->d_name,"/stat");
-      if((file_ptr = fopen(pathbuf,"r")) != NULL){
-         fscanf(file_ptr,
-            "%i %s %s %i %i\
-            %i %i %i %u %u\
-            %u %u %u %i %i\
-            %i %i %i %i %i\
-            %u %i %u %li %u\
-            %u %u %u %u %u\
-            %u %u %u %u %u\
-            %u %u %i %i",
-            &p.pid,        p.comm,       p.state,       &p.ppid,     &p.pgrp,
-            &p.session,    &p.tty_num,   &p.tpgid,      &p.flags,    &p.minflt,
-            &p.cminflt,    &p.majflt,    &p.cmajflt,    &p.utime,    &p.stime,
-            &p.cutime,     &p.cstime,    &p.priority,   &p.nice,     &temp,
-            &p.itrealvalue,&p.starttime, &p.vsize,      &p.rss,      &p.rlim,
-            &p.startcode,  &p.endcode,   &p.startstack, &p.kstkesp,  &p.kstkeip,
-            &p.signal,     &p.blocked,   &p.sigignore,  &p.sigcatch, &p.wchan,
-            &p.nswap,      &p.cnswap,    &p.exit_signal,&p.processor
-         );
-
-         fclose(file_ptr);
-      }
-
-      /* Get rid of the parens in the comm field */
-      strcpy(p.comm, strtok(p.comm,"()"));
-
-      /**********************************************************************
-       * Get the environ string out or /proc/PID/environ and make a hash
-       *  out of it
-       **********************************************************************/
-      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/environ");
-      if((file_ptr = fopen( pathbuf, "r" )) != NULL){
-
-         int count;
-         char env_buf[ARG_MAX];
-         char key[MAX_ENV_NAME];
-         char *next_var, *value;
-
-         /* Get char count */
-         count = fread(env_buf, sizeof(char), ARG_MAX, file_ptr); 
-         next_var = env_buf;
-
-         while(next_var < env_buf + count){
-            value = strchr(next_var,'=');
-            /***************************************************************
-             * It's possible some environ files contain data that's not in
-             * the KEY=value format.  For such cases, we'll just set the
-             * string as the key, and set the corresponding value to nil.
-             ***************************************************************/
-            if(NULL == value){
-               rb_hash_aset(v_env, rb_str_new2(next_var), Qnil);
-               break;
-            }
-            strncpy(key, next_var, value - next_var);
-            key[value-next_var] = '\0';
-
-            ++value;
-            rb_hash_aset(v_env, rb_str_new2(key), rb_str_new2(value));
-            next_var += strlen(next_var) + 1;
-         }
-
-         fclose(file_ptr);
-      }
-
-      /* If cmdline is empty, use comm instead */
-      if(0 == strlen(p.cmdline))
-         strcpy(p.cmdline, p.comm);
-      
-      v_pstruct = proctable_get_process(&p, v_env);
-
-      if(rb_block_given_p())
-         rb_yield(v_pstruct);
-      else
-         rb_ary_push(v_array, v_pstruct);
-   }
-
-   closedir(dir_ptr);
-
-   /* If a process ID was provided and found, return a single struct */
-   if(!NIL_P(v_pid))
-      return v_pstruct;
-   
-   return v_array; /* nil if block was provided */
-}
-
-/*
- * 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(VALUE klass){
-   unsigned int i;
-   VALUE rbFarray = rb_ary_new();
-   
-   for(i = 0; i < sizeof(fields)/sizeof(fields[0]); i++)
-      rb_ary_push(rbFarray,rb_str_new2(fields[i]));
-
-   return rbFarray;
-}
-
-/*
- * A Ruby interface for gathering process table information.
- */
-void Init_proctable()
-{
-   VALUE mSys, cProcTable;
-
-   /* Modules and Classes */
-   mSys = rb_define_module("Sys");
-   cProcTable = rb_define_class_under(mSys, "ProcTable", rb_cObject);
-   cProcError = rb_define_class_under(mSys, "ProcTableError",rb_eStandardError);
-   
-   /* Class Methods */
-   rb_define_singleton_method(cProcTable, "fields", proctable_fields, 0);
-   rb_define_singleton_method(cProcTable, "ps", proctable_ps, -1);
-
-   /* Constants */
-   rb_define_const(cProcTable,"VERSION",rb_str_new2(SYS_PROCTABLE_VERSION));
-
-   /* Structs */
-   sProc = rb_struct_define("ProcTableStruct","cmdline","cwd","exe","pid",
-      "name", "uid", "euid", "gid", "egid", "comm","state","ppid",
-      "pgrp","session","tty_num","tpgid","flags","minflt","cminflt","majflt",
-      "cmajflt","utime","stime","cutime","cstime","priority","nice",
-      "itrealvalue","starttime","vsize","rss","rlim","startcode","endcode",
-      "startstack","kstkesp","kstkeip","signal","blocked","sigignore",
-      "sigcatch","wchan","nswap","cnswap","exit_signal","processor","environ",
-      NULL
-   );
-}
-
-#ifdef __cplusplus
-}
-#endif