proc-wait3 1.5.1 → 1.5.2

data/CHANGES

@@ -1,3 +1,12 @@
+== 1.5.2 - 24-Jul-2006
+* Fixed the way I was handling whether or not Ruby already defined the various
+  RLIMIT constants within wait3.c.
+* Fixed the way in which certain RLIM constants were being converted. I
+  shamelessly plagiarized from process.c for this.
+* Adds the RLIMIT_MEMLOCK constant if found and not already defined.
+* Added the WAIT3_VERSION constant.
+* The getrlimit and setrlimit tests are now skipped for Ruby 1.8.5 or later.
+
 == 1.5.1 - 13-Jul-2006
 * Fixed bugs with improper values being set for some of the rlimit constants.
 * Cleaned up a few warnings related to signed-ness for the RLIM_xxx constants.

data/README

@@ -1,6 +1,7 @@
 == Description
    Adds the wait3, wait4, waitid, pause, sigsend, and getrusage methods to
-   the Process module.
+   the Process module. For Ruby 1.8.4 or earlier, it also adds the getrlimit
+   and setrlimit methods.
 
 == Installation
    ruby extconf.rb
@@ -29,7 +30,9 @@ threads for more information. Also available as ruby-Patches-1486 on the
 RubyForge project page for Ruby.
 
 To apply the patch, simply run "ruby patch.rb". Note that you may need to be
-root to apply the patch.
+root to apply the patch.  This may fail in Ruby 1.8.5 or later.  Since there's
+no good way to make a compatible diff, you will just have to edit the mkmf.rb
+file manually.
 
 == Integration with Ruby's process.c
 I considered simply providing a patch to the core process.c file, but I

data/doc/wait3.txt

@@ -1,6 +1,7 @@
 == Description
    Adds the wait3, wait4, waitid, pause, sigsend, and getrusage methods to
-   the Process module.
+   the Process module.  For Ruby 1.8.4 or earlier, it also adds the getrlimit
+   and setrlimit methods.
 
 == Synopsis
    require "proc/wait3"
@@ -71,7 +72,20 @@ Proc.waitid(id_type, id_num=nil, options=nil)
 
    Not supported on all platforms.
 
+== Ruby 1.8.4 or earlier.
+Process.getrlimit(resource) => [cur_limit, max_limit]
+   Returns a two element array consisting of the hard and soft limit
+   for the current process for the given +resource+.  The array consists of
+   either numeric values or the word "infinite".
+   
+Process.setrlimit(resource, current, max=nil) => nil
+   Sets the resource limit for +resource+ to +current+ for the soft limit and
+   +max+ for the hard limit, or to +current+ if +max+ is nil.
+
 == Constants
+=== Standard
+Process::WAIT3_VERSION
+   Returns the version of this package as a string.
 
 === Process type constants
 ==== All platforms
@@ -123,15 +137,50 @@ Process::WTRAPPED
    Wait for traced process(es) to become trapped or reach a breakpoint.
 
    Not supported on all platforms.
+   
+=== RLIMIT constants
+Process::RLIMIT_AS
+   A synonym for RLIMIT_VMEM
+   
+Process::RLIMIT_CORE
+   The maximum size of a core file, in bytes, that may be created.
+   
+Process::RLIMIT_CPU
+   The maximum amount of CPU time, in seconds, the process is allowed to use.
+   
+Process::RLIMIT_DATA
+   The maximum size of the process' heap size, in bytes.
+   
+Process::RLIMIT_FSIZE
+   The maximum size of a file, in bytes, that the process may create.
+   
+Process::RLIMIT_NOFILE
+   The maximum value that the kernel may assign to a file descriptor,
+   effectively limiting the number of open files for the calling process.
+   
+Process::RLIMIT_STACK
+   The maximum size of the process' stack in bytes.
+   
+Process::RLIMIT_VMEM
+   The maximum size of the process' mapped address space.
+   
+Process::RLIM_INFINITY
+   A infinite limit.
+   
+Process::RLIM_SAVED_CUR
+   Current soft limit.
+   
+Process::RLIM_SAVED_MAX
+   Current hard limit.
 
 == Notes
-   The wait3 and wait4 methods are similar to the wait2() and waitpid2()
+   The wait3 and wait4 methods are similar to the wait2 and waitpid2
    methods, except that they return much more information via the rusage
    struct.
 
 == Known Bugs
-   None that I'm aware of.  Please log any bugs on the SourceForge project
-   page at http://ruby-miscutils.sf.net.
+   None that I'm aware of.  Please log any bugs on the RubyForge project
+   page at http://www.rubyforge.org/projects/shards.
 
 == License
    Ruby's

data/extconf.rb

@@ -7,6 +7,25 @@ require "ftools"
 
 File.copy("lib/proc/wait3.c",".")
 
+# Check to see if Ruby has already defined the various RLIMIT constants
+# and set an appropriate macro in the source.
+begin
+   Process::RLIMIT_AS
+rescue
+   check_sizeof("int")
+   check_sizeof("long")
+   check_sizeof("long long")
+   unless check_sizeof("rlim_t", "sys/resource.h")
+      if (2**33).is_a?(Fixnum)
+         $defs.push("-DSIZEOF_RLIM_T 8") # 64 bit
+      else
+         $defs.push("-DSIZEOF_RLIM_T 4") # 32 bit
+      end
+   end
+else
+   $defs.push("-DRUBY_HAS_RLIMIT") # Used within wait.c
+end
+
 have_header("wait.h")
 
 # wait3 is mandatory.

data/lib/proc/wait3.c

@@ -17,6 +17,20 @@
 #define SIG2STR_MAX 32
 #endif
 
+/* Copied from process.c in Ruby 1.8.5 */
+#ifndef RUBY_HAS_RLIMIT
+#if SIZEOF_RLIM_T == SIZEOF_INT
+# define RLIM2NUM(v) UINT2NUM(v)
+# define NUM2RLIM(v) NUM2UINT(v)
+#elif SIZEOF_RLIM_T == SIZEOF_LONG
+# define RLIM2NUM(v) ULONG2NUM(v)
+# define NUM2RLIM(v) NUM2ULONG(v)
+#elif SIZEOF_RLIM_T == SIZEOF_LONG_LONG
+# define RLIM2NUM(v) ULL2NUM(v)
+# define NUM2RLIM(v) NUM2ULL(v)
+#endif
+#endif
+
 VALUE v_last_status;
 VALUE v_procstat_struct, v_siginfo_struct, v_usage_struct;
 
@@ -295,6 +309,7 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
    idtype_t idtype;
    id_t id = 0;
    int options = 0;
+   int i = 0;
 
    rb_scan_args(argc, argv, "12", &v_type, &v_id, &v_options);
 
@@ -430,7 +445,6 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
       }
 
       if(sig == SIGPROF){
-         int i = 0;
 #ifdef HAVE_ST_SI_SYSARG
          int ssize = sizeof(infop.si_sysarg) / sizeof(infop.si_sysarg[0]);
          rbSysarg  = rb_ary_new();
@@ -701,21 +715,22 @@ static VALUE proc_getrusage(int argc, VALUE* argv, VALUE mod){
 }
 #endif
 
+#ifndef RUBY_HAS_RLIMIT
 /*
  * call-seq:
- *    Process.getrlimit(resource)
+ *    Process.getrlimit(resource) => [cur_limit, max_limit]
  *
  * Returns a two element array consisting of the hard and soft limit
  * for the current process for the given +resource+.  The array consists of
  * either numeric values or the word "infinite".
  */
-static VALUE proc_getrlimit(VALUE mod, VALUE rbResource){
+static VALUE proc_getrlimit(VALUE mod, VALUE v_resource){
    struct rlimit limits;
    VALUE v_array = rb_ary_new();
 
    rb_secure(2);
 
-   if(getrlimit(NUM2INT(rbResource), &limits) < 0)
+   if(getrlimit(NUM2INT(v_resource), &limits) < 0)
       rb_sys_fail("getrlimit");
 
    if(limits.rlim_cur == RLIM_INFINITY)
@@ -733,24 +748,32 @@ static VALUE proc_getrlimit(VALUE mod, VALUE rbResource){
 
 /*
  * call-seq;
- *    Process.setrlimit(resource, current, max)
+ *    Process.setrlimit(resource, current, max=nil) => nil
  *
- * Sets the current (soft) and max (hard) limit for the given +resource+ for
- * the current process.
+ * Sets the +current+ (soft) and +max+ (hard) limit for the given +resource+
+ * for the current process.  If +max+ is nil it is set to the same value as
+ * +current+.
  */
-static VALUE proc_setrlimit(VALUE mod, VALUE rbRes, VALUE rbCur, VALUE rbMax){
+static VALUE proc_setrlimit(int argc, VALUE* argv, VALUE mod){
+   VALUE v_res, v_cur, v_max;
    struct rlimit limits;
 
    rb_secure(2);
 
-   limits.rlim_cur = NUM2INT(rbCur);
-   limits.rlim_max = NUM2INT(rbMax);
+   rb_scan_args(argc, argv, "21", &v_res, &v_cur, &v_max);
 
-   if(setrlimit(NUM2INT(rbRes), &limits) == -1)
+   if(NIL_P(v_max))
+      v_max = v_cur;
+
+   limits.rlim_cur = RLIM2NUM(v_cur);
+   limits.rlim_max = RLIM2NUM(v_max);
+
+   if(setrlimit(NUM2UINT(v_res), &limits) < 0)
       rb_sys_fail("setrlimit");
 
    return Qnil;
 }
+#endif
 
 /*
  * Adds the wait3, wait4, waitid, pause, sigsend, and getrusage methods to the
@@ -768,8 +791,11 @@ void Init_wait3()
 
    rb_define_module_function(rb_mProcess, "wait3", proc_wait3, -1);
    rb_define_module_function(rb_mProcess, "pause", proc_pause, -1);
+
+#ifndef RUBY_HAS_RLIMIT
    rb_define_module_function(rb_mProcess, "getrlimit", proc_getrlimit, 1);
-   rb_define_module_function(rb_mProcess, "setrlimit", proc_setrlimit, 3);
+   rb_define_module_function(rb_mProcess, "setrlimit", proc_setrlimit, -1);
+#endif
 
 #ifdef HAVE_SIGSEND
    rb_define_module_function(rb_mProcess, "sigsend", proc_sigsend, -1);
@@ -883,10 +909,10 @@ void Init_wait3()
 #endif
 
    /* Constants for getrlimit, setrlimit.  It appears that these are defined
-    * by Ruby as of 1.8.5.  Assume that if RLIMIT_AS is defined, all the
-    * standard rlimit constants are defined.
+    * by Ruby as of 1.8.5.  We'll only set the RLIMIT constants for Ruby 1.8.4
+    * or earlier.
     */
-#ifndef RLIMIT_AS
+#ifndef RUBY_HAS_RLIMIT
    rb_define_const(rb_mProcess, "RLIMIT_AS", INT2FIX(RLIMIT_AS));
    rb_define_const(rb_mProcess, "RLIMIT_CORE", INT2FIX(RLIMIT_CORE));
    rb_define_const(rb_mProcess, "RLIMIT_CPU", INT2FIX(RLIMIT_CPU));
@@ -894,14 +920,20 @@ void Init_wait3()
    rb_define_const(rb_mProcess, "RLIMIT_FSIZE", INT2FIX(RLIMIT_FSIZE));
    rb_define_const(rb_mProcess, "RLIMIT_NOFILE", INT2FIX(RLIMIT_NOFILE));
    rb_define_const(rb_mProcess, "RLIMIT_STACK", INT2FIX(RLIMIT_STACK));
-   rb_define_const(rb_mProcess, "RLIM_INFINITY", UINT2NUM(RLIM_INFINITY));
-   rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", UINT2NUM(RLIM_SAVED_MAX));
-   rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", UINT2NUM(RLIM_SAVED_CUR));
+   rb_define_const(rb_mProcess, "RLIM_INFINITY", RLIM2NUM(RLIM_INFINITY));
+   rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", RLIM2NUM(RLIM_SAVED_MAX));
+   rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", RLIM2NUM(RLIM_SAVED_CUR));
+
+#ifdef RLIMIT_MEMLOCK
+   rb_define_const(rb_mProcess, "RLIMIT_MEMLOCK", INT2FIX(RLIMIT_MEMLOCK));
 #endif
 
 #ifdef RLIMIT_VMEM
    rb_define_const(rb_mProcess, "RLIMIT_VMEM", INT2FIX(RLIMIT_VMEM));
 #endif
+#endif
+
+   rb_define_const(rb_mProcess, "WAIT3_VERSION", rb_str_new2("1.5.2"));
 
    /* Define this last in our Init_wait3 function */
    rb_define_readonly_variable("$?", &v_last_status);

data/test/tc_wait3.rb

@@ -31,6 +31,10 @@ class TC_Wait3 < Test::Unit::TestCase
          "termsig", "stopsig"]
    end
 
+   def test_wait3_version
+      assert_equal('1.5.2', Process::WAIT3_VERSION)
+   end
+
    def test_wait3_basic
       assert_respond_to(Process,:wait3)
    end
@@ -126,7 +130,7 @@ end
       pid = fork{ sleep 1 }
       assert_nothing_raised{ Process.getrusage }
       assert_nothing_raised{ Process.getrusage(true) }
-      assert_kind_of(Struct::RUsage,Process.getrusage)
+      assert_kind_of(Struct::RUsage, Process.getrusage)
    end
 
    def test_wait_constants
@@ -140,22 +144,32 @@ end
       assert_not_nil(Process::WTRAPPED, msg) unless RUBY_PLATFORM.match("linux")
    end
 
-   def test_getrlimit
-      assert_respond_to(Process, :getrlimit)
-      assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_CPU) }
-      assert_kind_of(Array, Process.getrlimit(Process::RLIMIT_CPU))
-      assert_equal(2, Process.getrlimit(Process::RLIMIT_CPU).length)
-   end
+   # Skip these tests on Ruby 1.8.5 or later
+   #
+   if RUBY_VERSION.split('.').last.to_i <= 4
+      def test_getrlimit
+         assert_respond_to(Process, :getrlimit)
+         assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_CPU) }
+         assert_kind_of(Array, Process.getrlimit(Process::RLIMIT_CPU))
+         assert_equal(2, Process.getrlimit(Process::RLIMIT_CPU).length)
+      end
 
-   def test_setrlimit
-      assert_respond_to(Process, :setrlimit)
-      assert_nothing_raised{
-         Process.setrlimit(
-            Process::RLIMIT_CPU,
-            Process::RLIM_SAVED_CUR,
-            Process::RLIM_SAVED_MAX
-         )
-      }
+      def test_setrlimit
+         assert_respond_to(Process, :setrlimit)
+         assert_nothing_raised{
+            Process.setrlimit(
+               Process::RLIMIT_CPU,
+               Process::RLIM_SAVED_CUR,
+               Process::RLIM_SAVED_MAX
+            )
+         }
+         assert_nothing_raised{
+            Process.setrlimit(Process::RLIMIT_CPU, Process::RLIM_SAVED_CUR)
+         }
+      end
+   else
+      STDOUT.puts('Process.getrlimit test skipped for Ruby 1.8.5 or later')
+      STDOUT.puts('Process.setrlimit test skipped for Ruby 1.8.5 or later')
    end
 
    # Test to ensure that the various rlimit constants are defined.  Note that
@@ -175,6 +189,16 @@ end
       assert_not_nil(Process::RLIM_SAVED_CUR)
    end
 
+   # This test was added to ensure that these three constants are being
+   # defined properly after an issue appeared on Linux with regards to
+   # the value accidentally being assigned a negative value.
+   #
+   def test_rlimit_constants_valid
+      assert(Process::RLIM_INFINITY > 0)
+      assert(Process::RLIM_SAVED_MAX > 0)
+      assert(Process::RLIM_SAVED_CUR > 0)
+   end
+
    def test_process_type_flags
       unless RUBY_PLATFORM.match("linux")
          assert_not_nil(Process::P_ALL)

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: proc-wait3
 version: !ruby/object:Gem::Version 
-  version: 1.5.1
-date: 2006-07-13 00:00:00 -06:00
-summary: Adds the wait3, wait4, waitid, pause, sigsend, and getrusage methods to the Process module
+  version: 1.5.2
+date: 2006-07-24 00:00:00 -06:00
+summary: Adds the wait3, wait4, waitid, pause, sigsend, and getrusage methods to the Process module.  It also adds the getrlimit and setrlimit methods for Ruby 1.8.4 or earlier.
 require_paths: 
 - lib
 email: djberg96@gmail.com
 homepage: http://www.rubyforge.org/projects/shards
 rubyforge_project: shards
-description: Adds the wait3, wait4, waitid, pause, sigsend, and getrusage methods to the Process module
+description: Adds the wait3, wait4, waitid, pause, sigsend, and getrusage methods to the Process module.  It also adds the getrlimit and setrlimit methods for Ruby 1.8.4 or earlier.
 autorequire: 
 default_executable: 
 bindir: bin