sys-proctable 0.9.4-universal-darwin → 0.9.5-universal-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11f52508143ac983c07b528b5622e940486a41f1
-  data.tar.gz: 1a897f239ba90adf065767ee4a58d3a3d2578dbf
+  metadata.gz: 3b1cdd14b7384e61fcbaebc7cb065b44a9e93c45
+  data.tar.gz: 42ba4f461988cb3cddb6509e5e650e7acbf6cd02
 SHA512:
-  metadata.gz: e3a8a5a456d03c9131dddb824159718832f77e3d41d21f344a5e3c2b41f002a165bf9a651b71f058aacb9edd795ba6a85fa29e9e5feaecb6fe25d2f5569a492a
-  data.tar.gz: bfef4c48d0089ffea5b5200c8a16aeaa2ab83437dcb3d5e7b4eed360241877a7eebc7735a0e78882f3aaff5e87359ed761c72fa5283833c0e2a43657fb3204ca
+  metadata.gz: b94812963041c9a7870fcd5ad145f0b1d0d7e4374fd7e37b7ce13ac19aa5246a19bf8870c09523ec71a4ff9e4ab9aecaba5a263eb79b3708b3b12a5f79830e4d
+  data.tar.gz: 90a56eff492e110906c5d14b199dabc6964919e933405f39ebe97079867d5a9d9f36970f7df7d1ad78ab48efec7470c4cd3f73958a7ca800e52bfa2aed2226d6

data/CHANGES

@@ -1,3 +1,9 @@
+== 0.9.5 - 10-Feb-2015
+* Significant cleanup and memory reduction of the OSX code. Thanks go
+  to Ivan (toy) for the patches.
+* Skip over /proc/<file>/status if unreadable on Linux. Thanks go to Jianjun
+  Mao for the patch.
+
 == 0.9.4 - 4-Mar-2014
 * Added support for AIX 5.3 or later courtesy of Rick Ohnemus.
 * The Solaris version now uses FFI structs instead of a packed array.

data/Rakefile

@@ -174,6 +174,8 @@ namespace :gem do
          spec.files += ['lib/windows/sys/proctable.rb']
          spec.test_files << 'test/test_sys_proctable_windows.rb'
     end
+
+    spec.test_files << 'test/test_sys_top.rb'
  
     # https://github.com/rubygems/rubygems/issues/147
     spec.original_platform = spec.platform

data/ext/darwin/sys/proctable.c

@@ -20,7 +20,7 @@
 
 #define pid_of(pproc) pproc->kp_proc.p_pid
 
-#define SYS_PROCTABLE_VERSION "0.9.4"
+#define SYS_PROCTABLE_VERSION "0.9.5"
 
 #define PROC_MIB_LEN 4
 #define ARGS_MIB_LEN 3
@@ -31,15 +31,7 @@
 
 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"
-};
-
-int argv_of_pid(int pid, char* cmdline) {
+int argv_of_pid(int pid, VALUE* v_cmdline, VALUE* v_exe, VALUE* v_environ) {
   int    mib[3], argmax, nargs, c = 0;
   size_t    size;
   char    *procargs, *sp, *np, *cp;
@@ -116,6 +108,9 @@ int argv_of_pid(int pid, char* cmdline) {
   memcpy(&nargs, procargs, sizeof(nargs));
   cp = procargs + sizeof(nargs);
 
+  /* Copy exec_path to ruby String. */
+  *v_exe = rb_str_new2(cp);
+
   /* Skip the saved exec_path. */
   for (; cp < &procargs[size]; cp++) {
     if (*cp == '\0') {
@@ -151,22 +146,22 @@ int argv_of_pid(int pid, char* cmdline) {
     if (*cp == '\0') {
       c++;
       if (np != NULL) {
-          /* Convert previous '\0'. */
-          *np = ' ';
+        /* Convert previous '\0'. */
+        *np = ' ';
       } else {
-          /* *argv0len = cp - sp; */
+        /* *argv0len = cp - sp; */
       }
       /* Note location of current '\0'. */
       np = cp;
 
       if (!show_args) {
-          /*
-           * Don't convert '\0' characters to ' '.
-           * However, we needed to know that the
-           * command name was terminated, which we
-           * now know.
-           */
-          break;
+        /*
+         * Don't convert '\0' characters to ' '.
+         * However, we needed to know that the
+         * command name was terminated, which we
+         * now know.
+         */
+        break;
       }
     }
   }
@@ -180,8 +175,19 @@ int argv_of_pid(int pid, char* cmdline) {
     goto ERROR_B;
   }
 
-  /* Make a copy of the string. */
-  strcpy(cmdline, sp);
+  /* Make a copy of the string to ruby String. */
+  *v_cmdline = rb_str_new2(sp);
+
+  /* Read environment variables to ruby Hash. */
+  *v_environ = rb_hash_new();
+  while (cp[0]) {
+    sp = strsep(&cp, "=");
+    if (sp == NULL) {
+      break;
+    }
+    rb_hash_aset(*v_environ, rb_str_new2(sp), rb_str_new2(cp));
+    cp += strlen(cp) + 1;
+  }
 
   /* Clean up. */
   free(procargs);
@@ -206,163 +212,161 @@ int argv_of_pid(int pid, char* cmdline) {
  * 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;
+  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;
+  int g;
+  VALUE v_cmdline, v_exe, v_environ, v_groups;
+
+  // 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;
+
+    // cmdline will be set only if process exists and belongs to current user or
+    // current user is root
+    v_cmdline = Qnil;
+    v_exe = Qnil;
+    v_environ = Qnil;
+    argv_of_pid(procs[i].kp_proc.p_pid, &v_cmdline, &v_exe, &v_environ);
+
+    // 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;
+    }
 
-      *args = '\0';
+    // 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));
+    }
 
-      /* Query the command line args */
-      /* TODO: Cmd line not working for now - fix */
+    v_groups = rb_ary_new();
+    for (g = 0; g < procs[i].kp_eproc.e_ucred.cr_ngroups; ++g) {
+      rb_ary_push(v_groups, INT2FIX(procs[i].kp_eproc.e_ucred.cr_groups[g]));
+    }
 
-      /*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);
+    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),
+      INT2FIX(procs[i].kp_eproc.e_ucred.cr_uid),
+      rb_ary_entry(v_groups, 0),
+      v_groups,
+      INT2FIX(procs[i].kp_eproc.e_pcred.p_svuid),
+      INT2FIX(procs[i].kp_eproc.e_pcred.p_svgid),
+      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),
+      v_cmdline,
+      v_exe,
+      v_environ,
+      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(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);
-      }*/
-      char cmdline[ARGS_MAX_LEN+1];
-
-      argv_of_pid(procs[i].kp_proc.p_pid, cmdline);
-      // free(cmdline);
-
-      // 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;
-      }
+  if(procs) free(procs);
 
-      // 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));
-      }
+  if(!rb_block_given_p()){
+    if(NIL_P(v_pid))
+      return v_array;
+    else
+      return v_pstruct;
+  }
 
-      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(cmdline),
-         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;
+  return Qnil;
 }
 
 /*
@@ -374,52 +378,92 @@ static VALUE pt_ps(int argc, VALUE* argv, VALUE klass){
  * 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;
+  VALUE v_array = rb_ary_new();
+
+  VALUE v_members = rb_struct_s_members(sProcStruct), v_member;
+  long size = RARRAY_LEN(v_members);
+  int i;
 
-   for(i = 0; i < size; i++)
-      rb_ary_push(v_array, rb_str_new2(fields[i]));
+  for(i = 0; i < size; i++) {
+    v_member = rb_funcall(rb_ary_entry(v_members, i), rb_intern("to_s"), 0);
+    rb_ary_push(v_array, v_member);
+  }
 
-   return v_array;
+  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.3: 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
-   );
+  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.5: 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",         /* Process identifier */
+    "ppid",        /* Parent process id */
+    "pgid",        /* Process group id */
+    "ruid",        /* Real user id */
+    "rgid",        /* Real group id */
+    "euid",        /* Effective user id */
+    "egid",        /* Effective group id */
+    "groups",      /* All effective group ids */
+    "svuid",       /* Saved effective user id */
+    "svgid",       /* Saved effective group id */
+    "comm",        /* Command name (15 chars) */
+    "state",       /* Process status */
+    "pctcpu",      /* %cpu for this process during p_swtime */
+    "oncpu",       /* nil */
+    "tnum",        /* Controlling tty dev */
+    "tdev",        /* Controlling tty name */
+    "wmesg",       /* Wchan message */
+    "rtime",       /* Real time */
+    "priority",    /* Process priority */
+    "usrpri",      /* User-priority */
+    "nice",        /* Process "nice" value */
+    "cmdline",     /* Complete command line */
+    "exe",         /* Saved pathname of the executed command */
+    "environ",     /* Hash with process environment variables */
+    "starttime",   /* Process start time */
+    "maxrss",      /* Max resident set size (PL) */
+    "ixrss",       /* Integral shared memory size (NU) */
+    "idrss",       /* Integral unshared data (NU) */
+    "isrss",       /* Integral unshared stack (NU) */
+    "minflt",      /* Page reclaims (NU) */
+    "majflt",      /* Page faults (NU) */
+    "nswap",       /* Swaps (NU) */
+    "inblock",     /* Block input operations (atomic) */
+    "oublock",     /* Block output operations (atomic) */
+    "msgsnd",      /* Messages sent (atomic) */
+    "msgrcv",      /* Messages received (atomic) */
+    "nsignals",    /* Signals received (atomic) */
+    "nvcsw",       /* Voluntary context switches (atomic) */
+    "nivcsw",      /* Involuntary context switches (atomic) */
+    "utime",       /* User time used (PL) */
+    "stime",       /* System time used (PL) */
+    NULL
+  );
 }
-

data/sys-proctable.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'sys-proctable'
-  spec.version    = '0.9.4'
+  spec.version    = '0.9.5'
   spec.author     = 'Daniel J. Berger'
   spec.license    = 'Artistic 2.0' 
   spec.email      = 'djberg96@gmail.com'

data/test/test_sys_proctable_all.rb

@@ -19,7 +19,7 @@ class TC_ProcTable_All < Test::Unit::TestCase
   end
 
   def test_version
-    assert_equal('0.9.4', ProcTable::VERSION)
+    assert_equal('0.9.5', ProcTable::VERSION)
   end
 
   def test_fields
@@ -71,6 +71,12 @@ class TC_ProcTable_All < Test::Unit::TestCase
     assert_kind_of(StandardError, Sys::ProcTable::Error.new)
   end
 
+  def test_from_thread
+    Thread.new do
+      Sys::ProcTable.ps
+    end.value
+  end
+
   def teardown
     @pid  = nil
   end

data/test/test_sys_proctable_darwin.rb

@@ -12,15 +12,21 @@ include Sys
 class TC_ProcTable_Darwin < Test::Unit::TestCase
   def self.startup
     @@fields = %w/
-      pid ppid pgid ruid rgid comm state pctcpu oncpu tnum
-      tdev wmesg rtime priority usrpri nice cmdline starttime
+      pid ppid pgid ruid rgid euid egid groups svuid svgid
+      comm state pctcpu oncpu tnum
+      tdev wmesg rtime priority usrpri nice cmdline exe environ starttime
       maxrss ixrss idrss isrss minflt majflt nswap inblock oublock
       msgsnd msgrcv nsignals nvcsw nivcsw utime stime
     /
+
+    @@pid = fork do
+      exec('env', '-i', 'A=B', 'Z=', 'sleep', '60')
+    end
+    sleep 1 # wait to make sure env is replaced by sleep
   end
 
   def setup
-    @ptable = ProcTable.ps.last
+    @ptable = ProcTable.ps.find{ |ptable| ptable.pid == @@pid }
   end
 
   def test_fields
@@ -32,32 +38,67 @@ class TC_ProcTable_Darwin < Test::Unit::TestCase
   def test_pid
     assert_respond_to(@ptable, :pid)
     assert_kind_of(Fixnum, @ptable.pid)
+    assert_equal(@ptable.pid, @@pid)
   end
 
   def test_ppid
     assert_respond_to(@ptable, :ppid)
     assert_kind_of(Fixnum, @ptable.ppid)
+    assert_equal(Process.pid, @ptable.ppid)
   end
 
   def test_pgid
     assert_respond_to(@ptable, :pgid)
     assert_kind_of(Fixnum, @ptable.pgid)
+    assert_equal(Process.getpgrp, @ptable.pgid)
   end
 
   def test_ruid
     assert_respond_to(@ptable, :ruid)
     assert_kind_of(Fixnum, @ptable.ruid)
+    assert_equal(Process.uid, @ptable.ruid)
   end
 
   def test_rgid
     assert_respond_to(@ptable, :rgid)
     assert_kind_of(Fixnum, @ptable.rgid)
+    assert_equal(Process.gid, @ptable.rgid)
+  end
+
+  def test_euid
+    assert_respond_to(@ptable, :euid)
+    assert_kind_of(Fixnum, @ptable.euid)
+    assert_equal(Process.euid, @ptable.euid)
+  end
+
+  def test_egid
+    assert_respond_to(@ptable, :egid)
+    assert_kind_of(Fixnum, @ptable.egid)
+    assert_equal(Process.egid, @ptable.egid)
+  end
+
+  def test_groups
+    assert_respond_to(@ptable, :groups)
+    assert_kind_of(Array, @ptable.groups)
+    assert_equal(Process.groups, @ptable.groups)
+  end
+
+  def test_svuid
+    assert_respond_to(@ptable, :svuid)
+    assert_kind_of(Fixnum, @ptable.svuid)
+    assert_equal(Process.uid, @ptable.svuid) # not valid for all processes
+  end
+
+  def test_svgid
+    assert_respond_to(@ptable, :svgid)
+    assert_kind_of(Fixnum, @ptable.svgid)
+    assert_equal(Process.gid, @ptable.svgid) # not valid for all processes
   end
 
   def test_comm
     assert_respond_to(@ptable, :comm)
     assert_kind_of(String, @ptable.comm)
-    assert_true(@ptable.comm.length > 0)
+    assert_equal('sleep', @ptable.comm)
   end
 
   def test_state
@@ -114,6 +155,19 @@ class TC_ProcTable_Darwin < Test::Unit::TestCase
   def test_cmdline
     assert_respond_to(@ptable, :cmdline)
     assert_kind_of(String, @ptable.cmdline)
+    assert_equal('sleep 60', @ptable.cmdline)
+  end
+
+  def test_exe
+    assert_respond_to(@ptable, :exe)
+    assert_kind_of(String, @ptable.exe)
+    assert_equal(`which sleep`.chomp, @ptable.exe)
+  end
+
+  def test_environ
+    assert_respond_to(@ptable, :environ)
+    assert_kind_of(Hash, @ptable.environ)
+    assert_equal({'A' => 'B', 'Z' => ''}, @ptable.environ)
   end
 
   def test_starttime
@@ -207,5 +261,7 @@ class TC_ProcTable_Darwin < Test::Unit::TestCase
 
   def self.shutdown
     @@fields = nil
+
+    Process.kill('TERM', @@pid)
   end
 end

data/test/test_sys_top.rb

@@ -0,0 +1,46 @@
+##############################################################################
+# test_sys_top.rb
+#
+# Test suite for the sys-top library that is included with this distribution.
+##############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'sys/top'
+
+class TC_Top < Test::Unit::TestCase
+  include Sys
+
+  def test_version
+    assert_equal('1.0.4', Top::VERSION)
+  end
+
+  def test_top_basic
+    assert_respond_to(Top, :top)
+    assert_nothing_raised{ Top.top }
+    assert_nothing_raised{ Top.top(5) }
+    assert_nothing_raised{ Top.top(5, 'cmdline') }
+  end
+
+  def test_top
+    assert_equal(10, Top.top.length)
+    assert_kind_of(Struct::ProcTableStruct, Top.top.first)
+  end
+
+  def test_top_with_size
+    assert_equal(5, Top.top(5).length)
+  end
+
+  def test_top_with_size_and_sort_by_field
+    assert_equal(5, Top.top(5, :cmdline).length)
+  end
+
+  def test_top_return_type
+    assert_kind_of(Array, Top.top)
+  end
+
+  def test_top_expected_errors
+    assert_raises(ArgumentError){ Top.top(1, 'foo', 2) }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sys-proctable
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
 platform: universal-darwin
 authors:
 - Daniel J. Berger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-04 00:00:00.000000000 Z
+date: 2015-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -68,6 +68,7 @@ files:
 - sys-proctable.gemspec
 - test/test_sys_proctable_all.rb
 - test/test_sys_proctable_darwin.rb
+- test/test_sys_top.rb
 homepage: http://www.rubyforge.org/projects/sysutils
 licenses:
 - Artistic 2.0
@@ -88,10 +89,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: sysutils
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: An interface for providing process table information
 test_files:
 - test/test_sys_proctable_all.rb
 - test/test_sys_proctable_darwin.rb
+- test/test_sys_top.rb