sleepy_penguin 3.1.0.26.g7181 → 3.2.0

data/ext/sleepy_penguin/sleepy_penguin.h

@@ -77,4 +77,16 @@ static inline VALUE fake_blocking_region(VALUE (*fn)(void *), void *data)
 
 typedef int rb_sp_waitfn(int fd);
 int rb_sp_wait(rb_sp_waitfn waiter, VALUE obj, int *fd);
+
+/* Flexible array elements are standard in C99 */
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+# define FLEX_ARRAY
+#elif defined(__GNUC__)
+# if (__GNUC__ >= 3)
+#  define FLEX_ARRAY
+# else
+#  define FLEX_ARRAY 0
+# endif
+#endif
+
 #endif /* SLEEPY_PENGUIN_H */

data/ext/sleepy_penguin/value2timespec.h

@@ -53,7 +53,7 @@ static struct timespec *value2timespec(struct timespec *ts, VALUE num)
 #  define TIMET2NUM(n) LONG2NUM(n)
 #endif
 
-static VALUE timespec2num(struct timespec *ts)
+static inline VALUE timespec2num(struct timespec *ts)
 {
 	if (ts->tv_nsec == 0)
 		return TIMET2NUM(ts->tv_sec);

data/lib/sleepy_penguin.rb

@@ -1,11 +1,5 @@
 # -*- encoding: binary -*-
-module SleepyPenguin
-
-  # the version of sleepy_penguin, currently 3.1.0
-  SLEEPY_PENGUIN_VERSION = '3.1.0'
-end
 require 'sleepy_penguin_ext'
-require 'sleepy_penguin/epoll'
 
 # We need to serialize Inotify#take for Rubinius since that has no GVL
 # to protect the internal array

data/lib/sleepy_penguin/epoll.rb

@@ -1,45 +1,50 @@
 require 'thread'
 class SleepyPenguin::Epoll
 
-  # Epoll objects may be watched by IO.select and similar methods
-  attr_reader :to_io
-
   # call-seq:
   #     SleepyPenguin::Epoll.new([flags]) -> Epoll object
   #
   # Creates a new Epoll object with an optional +flags+ argument.
   # +flags+ may currently be +:CLOEXEC+ or +0+ (or +nil+).
   def initialize(create_flags = nil)
-    @to_io = SleepyPenguin::Epoll::IO.new(create_flags)
+    @io = SleepyPenguin::Epoll::IO.new(create_flags)
     @mtx = Mutex.new
     @events = []
     @marks = []
     @pid = $$
     @create_flags = create_flags
-    @copies = { @to_io => self }
+    @copies = { @io => self }
   end
 
   def __ep_reinit # :nodoc:
     @events.clear
     @marks.clear
-    @to_io = SleepyPenguin::Epoll::IO.new(@create_flags)
+    @io = SleepyPenguin::Epoll::IO.new(@create_flags)
   end
 
   # auto-reinitialize the Epoll object after forking
   def __ep_check # :nodoc:
     return if @pid == $$
-    return if @to_io.closed?
+    return if @io.closed?
     objects = @copies.values
     @copies.each_key { |epio| epio.close }
     @copies.clear
     __ep_reinit
     objects.each do |obj|
-      io_dup = @to_io.dup
+      io_dup = @io.dup
       @copies[io_dup] = obj
     end
     @pid = $$
   end
 
+  # Epoll objects may be watched by IO.select and similar methods
+  def to_io
+    @mtx.synchronize do
+      __ep_check
+      @io
+    end
+  end
+
   # Calls epoll_wait(2) and yields Integer +events+ and IO objects watched
   # for.  +maxevents+ is the maximum number of events to process at once,
   # lower numbers may prevent starvation when used by epoll_wait in multiple
@@ -59,10 +64,10 @@ class SleepyPenguin::Epoll
     # we keep a snapshot of @marks around in case another thread closes
     # the IO while it is being transferred to userspace.  We release mtx
     # so another thread may add events to us while we're sleeping.
-    @to_io.epoll_wait(maxevents, timeout) { |events, io| yield(events, io) }
+    @io.epoll_wait(maxevents, timeout) { |events, io| yield(events, io) }
   ensure
     # hopefully Ruby does not optimize this array away...
-    snapshot[0]
+    snapshot.clear
   end
 
   # Starts watching a given +io+ object with +events+ which may be an Integer
@@ -72,7 +77,7 @@ class SleepyPenguin::Epoll
     events = __event_flags(events)
     @mtx.synchronize do
       __ep_check
-      @to_io.epoll_ctl(CTL_ADD, io, events)
+      @io.epoll_ctl(CTL_ADD, io, events)
       @events[fd] = events
       @marks[fd] = io
     end
@@ -87,7 +92,7 @@ class SleepyPenguin::Epoll
     fd = io.to_io.fileno
     @mtx.synchronize do
       __ep_check
-      @to_io.epoll_ctl(CTL_DEL, io, 0)
+      @io.epoll_ctl(CTL_DEL, io, 0)
       @events[fd] = @marks[fd] = nil
     end
     0
@@ -110,7 +115,7 @@ class SleepyPenguin::Epoll
       __ep_check
       cur_io = @marks[fd]
       return if nil == cur_io || cur_io.to_io.closed?
-      @to_io.epoll_ctl(CTL_DEL, io, 0)
+      @io.epoll_ctl(CTL_DEL, io, 0)
       @events[fd] = @marks[fd] = nil
     end
     io
@@ -127,7 +132,7 @@ class SleepyPenguin::Epoll
     fd = io.to_io.fileno
     @mtx.synchronize do
       __ep_check
-      @to_io.epoll_ctl(CTL_MOD, io, events)
+      @io.epoll_ctl(CTL_MOD, io, events)
       @marks[fd] = io # may be a different object with same fd/file
       @events[fd] = events
     end
@@ -159,18 +164,18 @@ class SleepyPenguin::Epoll
         cur_events = @events[fd]
         return 0 if (cur_events & ONESHOT) == 0 && cur_events == events
         begin
-          @to_io.epoll_ctl(CTL_MOD, io, events)
+          @io.epoll_ctl(CTL_MOD, io, events)
         rescue Errno::ENOENT
           warn "epoll event cache failed (mod -> add)"
-          @to_io.epoll_ctl(CTL_ADD, io, events)
+          @io.epoll_ctl(CTL_ADD, io, events)
           @marks[fd] = io
         end
       else
         begin
-          @to_io.epoll_ctl(CTL_ADD, io, events)
+          @io.epoll_ctl(CTL_ADD, io, events)
         rescue Errno::EEXIST
           warn "epoll event cache failed (add -> mod)"
-          @to_io.epoll_ctl(CTL_MOD, io, events)
+          @io.epoll_ctl(CTL_MOD, io, events)
         end
         @marks[fd] = io
       end
@@ -186,8 +191,8 @@ class SleepyPenguin::Epoll
   # Raises IOError if object is already closed.
   def close
     @mtx.synchronize do
-      @copies.delete(@to_io)
-      @to_io.close
+      @copies.delete(@io)
+      @io.close
     end
   end
 
@@ -197,7 +202,7 @@ class SleepyPenguin::Epoll
   # Returns whether or not an Epoll object is closed.
   def closed?
     @mtx.synchronize do
-      @to_io.closed?
+      @io.closed?
     end
   end
 
@@ -254,9 +259,9 @@ class SleepyPenguin::Epoll
     @mtx.synchronize do
       __ep_check
       rv = super
-      unless @to_io.closed?
-        @to_io = @to_io.dup
-        @copies[@to_io] = self
+      unless @io.closed?
+        @io = @io.dup
+        @copies[@io] = self
       end
       rv
     end

data/lib/sleepy_penguin/kevent.rb

@@ -0,0 +1,7 @@
+# This class represents a "struct kevent" structure for Ruby.
+# This may be passed to Kqueue::IO#kevent as either a single element
+# or as an element inside an array to inject changes into the kevent
+# list.
+class SleepyPenguin::Kevent < Struct.new(:ident, :filter, :flags,
+                                         :fflags, :data, :udata)
+end

data/lib/sleepy_penguin/kqueue.rb

@@ -0,0 +1,122 @@
+require 'thread'
+
+# The high-level Kqueue interface.  This provides fork-safety under Ruby 1.9
+# and later (but not Ruby 1.8).
+# This also provides memory protection from bugs due to not storing an
+# external reference to an object, but still requires the user to store
+# their own object references.
+# Events registered to a Kqueue object cannot be shared across fork
+# due to the underlying implementation of kqueue in *BSDs.
+class SleepyPenguin::Kqueue
+
+  # Initialize a new Kqueue object, this allocates an underlying Kqueue::IO
+  # object and may fail if the system is out of file descriptors or
+  # kernel memory
+  def initialize
+    @io = SleepyPenguin::Kqueue::IO.new
+    @mtx = Mutex.new
+    @pid = $$
+    @copies = { @io => self }
+  end
+
+  # Kqueue objects may be watched by IO.select and similar methods
+  def to_io
+    @mtx.synchronize do
+      __kq_check
+      @io
+    end
+  end
+
+  def __kq_reinit # :nodoc:
+    @io = SleepyPenguin::Kqueue::IO.new
+  end
+
+  def __kq_check # :nodoc:
+    return if @pid == $$ || @io.closed?
+    unless @io.respond_to?(:autoclose=)
+      raise RuntimeError,
+       "Kqueue is not safe to use without IO#autoclose=, upgrade to Ruby 1.9+"
+    end
+
+    # kqueue has (strange) close-on-fork behavior
+    objects = @copies.values
+    @copies.each_key { |kqio| kqio.autoclose = false }
+    @copies.clear
+    __kq_reinit
+    objects.each do |obj|
+      io_dup = @io.dup
+      @copies[io_dup] = obj
+    end
+    @pid = $$
+  end
+
+  # A high-level wrapper around Kqueue::IO#kevent
+  # Users are responsible for ensuring +udata+ objects remain visible to the
+  # Ruby GC, otherwise ObjectSpace._id2ref may return invalid objects.
+  # Unlike the low-level Kqueue::IO#kevent, the block given yields only
+  # a single Kevent struct, not a 6-element array.
+  def kevent(changelist = nil, *args)
+    @mtx.synchronize { __kq_check }
+    if changelist
+      changelist = [ changelist ] if Struct === changelist
+
+      # store the object_id instead of the raw VALUE itself in kqueue and
+      # use _id2ref to safely recover the object without the possibility of
+      # invalid memory acccess.
+      #
+      # We may still raise and drop events due to user error
+      changelist = changelist.map do |item|
+        item = item.dup
+        item[5] = item[5].object_id
+        item
+      end
+    end
+
+    if block_given?
+      n = @io.kevent(changelist, *args) do |ident,filter,flags,
+                                               fflags,data,udata|
+        # This may raise and cause events to be lost,
+        # that's the users' fault/problem
+        udata = ObjectSpace._id2ref(udata)
+        yield SleepyPenguin::Kevent.new(ident, filter, flags,
+                                        fflags, data, udata)
+      end
+    else
+      n = @io.kevent(changelist, *args)
+    end
+  end
+
+  def initialize_copy(src) # :nodoc:
+    @mtx.synchronize do
+      __kq_check
+      rv = super
+      unless @io.closed?
+        @io = @io.dup
+        @copies[@io] = self
+      end
+      rv
+    end
+  end
+
+  # call-seq:
+  #     kq.close -> nil
+  #
+  # Closes an existing Kqueue object and returns memory back to the kernel.
+  # Raises IOError if object is already closed.
+  def close
+    @mtx.synchronize do
+      @copies.delete(@io)
+      @io.close
+    end
+  end
+
+  # call-seq:
+  #     kq.closed? -> true or false
+  #
+  # Returns whether or not an Kqueue object is closed.
+  def closed?
+    @mtx.synchronize do
+      @io.closed?
+    end
+  end
+end

data/lib/sleepy_penguin/kqueue/io.rb

@@ -0,0 +1,30 @@
+class SleepyPenguin::Kqueue::IO
+  # :stopdoc:
+  # this file is only for Ruby 1.8 green threads compatibility
+  alias __kevent kevent
+  undef_method :kevent
+
+  def __update_timeout(expire_at)
+    now = Time.now
+    diff = expire_at - now
+    diff > 0 ? diff : 0
+  end
+
+  def kevent(changelist = nil, nevents = nil, timeout = nil)
+    if block_given?
+      expire_at = timeout ? Time.now + timeout : nil
+      begin
+        IO.select([self], nil, nil, timeout)
+        n = __kevent(changelist, nevents, 0) do |*args|
+          yield(*args)
+        end
+      end while n == 0 && timeout != 0 &&
+                (expire_at == nil || timeout = __update_timeout(expire_at))
+      n
+    else
+      # nevents should be zero or nil here
+      __kevent(changelist, nevents, 0)
+    end
+  end
+  # :startdoc:
+end

data/pkg.mk

@@ -36,7 +36,7 @@ $(ext_pfx)/$(ext)/%: $(ext)/% $(ext_d)
 	install -m 644 $< $@
 $(ext_pfx)/$(ext)/Makefile: $(ext)/extconf.rb $(ext_d) $(ext_h)
 	$(RM) -f $(@D)/*.o
-	cd $(@D) && $(RUBY) $(CURDIR)/$(ext)/extconf.rb
+	cd $(@D) && $(RUBY) $(CURDIR)/$(ext)/extconf.rb $(EXTCONF_ARGS)
 ext_sfx := _ext.$(DLEXT)
 ext_dl := $(ext_pfx)/$(ext)/$(notdir $(ext)_ext.$(DLEXT))
 $(ext_dl): $(ext_src) $(ext_pfx_src) $(ext_pfx)/$(ext)/Makefile

data/test/test_constants.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+$-w = true
+Thread.abort_on_exception = true
+require 'sleepy_penguin/sp'
+
+class TestConstants < Test::Unit::TestCase
+  def test_constants
+    assert_equal SleepyPenguin::SLEEPY_PENGUIN_VERSION,
+                 SP::SLEEPY_PENGUIN_VERSION
+    v = SP::SLEEPY_PENGUIN_VERSION.split('.')
+
+    (0..2).each do |i|
+      assert_equal v[i], v[i].to_i.to_s, v.inspect
+    end
+  end
+end

data/test/test_epoll.rb

@@ -9,7 +9,6 @@ require 'sleepy_penguin'
 
 class TestEpoll < Test::Unit::TestCase
   include SleepyPenguin
-  RBX = defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'rbx')
 
   def setup
     @rd, @wr = IO.pipe
@@ -122,11 +121,9 @@ class TestEpoll < Test::Unit::TestCase
   end
 
   def teardown
-    assert_nothing_raised do
-      @rd.close unless @rd.closed?
-      @wr.close unless @wr.closed?
-      @ep.close unless @ep.closed?
-    end
+    @rd.close unless @rd.closed?
+    @wr.close unless @wr.closed?
+    @ep.close unless @ep.closed?
   end
 
   def test_max_events_big
@@ -156,11 +153,17 @@ class TestEpoll < Test::Unit::TestCase
   end
 
   def test_signal_safe_wait_forever
+    sigpipe = IO.pipe
     time = {}
+    thr = Thread.new do
+      IO.select([sigpipe[0]]) # wait for USR1
+      sigpipe[0].read(1)
+      sleep 0.5
+      @wr.syswrite '.'
+    end
     trap(:USR1) do
       time[:USR1] = Time.now
-      sleep 0.5
-      @wr.write '.'
+      sigpipe[1].syswrite('.') # wake up thr
     end
     @ep.add @rd, Epoll::IN
     tmp = []
@@ -170,11 +173,9 @@ class TestEpoll < Test::Unit::TestCase
       exit!(0)
     end
     time[:START_WAIT] = Time.now
-    assert_nothing_raised do
-      @ep.wait do |flags, obj|
-        tmp << [ flags, obj ]
-        time[:EP] = Time.now
-      end
+    @ep.wait do |flags, obj|
+      tmp << [ flags, obj ]
+      time[:EP] = Time.now
     end
     assert_equal([[Epoll::IN, @rd]], tmp)
     _, status = Process.waitpid2(pid)
@@ -183,9 +184,12 @@ class TestEpoll < Test::Unit::TestCase
     assert_in_delta(0.5, usr1_delay, 0.1, "usr1_delay=#{usr1_delay}")
     ep_delay = time[:EP] - time[:USR1]
     assert_in_delta(0.5, ep_delay, 0.1, "ep1_delay=#{ep_delay}")
+    assert_kind_of Thread, thr
+    thr.join
     ensure
+      sigpipe.each { |io| io.close }
       trap(:USR1, 'DEFAULT')
-  end unless RBX
+  end
 
   def test_close
     @ep.add @rd, Epoll::IN
@@ -193,10 +197,12 @@ class TestEpoll < Test::Unit::TestCase
     thr = Thread.new { @ep.wait { |flags, obj| tmp << [ flags, obj ] } }
     @rd.close
     @wr.close
-    assert_nil thr.join(0.01)
+    Thread.pass
+    assert_nil thr.join(0.25)
     assert thr.alive?
     thr.kill
     assert tmp.empty?
+    thr.join
   end
 
   def test_rdhup
@@ -222,12 +228,10 @@ class TestEpoll < Test::Unit::TestCase
 
   def test_multiple
     r, w = IO.pipe
-    assert_nothing_raised do
-      @ep.add r, Epoll::IN
-      @ep.add @rd, Epoll::IN
-      @ep.add w, Epoll::OUT
-      @ep.add @wr, Epoll::OUT
-    end
+    @ep.add r, Epoll::IN
+    @ep.add @rd, Epoll::IN
+    @ep.add w, Epoll::OUT
+    @ep.add @wr, Epoll::OUT
     tmp = []
     @ep.wait { |flags, obj| tmp << [ flags, obj ] }
     assert_equal 2, tmp.size
@@ -237,21 +241,6 @@ class TestEpoll < Test::Unit::TestCase
     assert ios.include?(w)
   end
 
-  def test_gc
-    assert_nothing_raised { 4096.times { Epoll.new } }
-    assert ! @ep.closed?
-  end unless RBX
-
-  def test_gc_to_io
-    assert_nothing_raised do
-      4096.times do
-        ep = Epoll.new
-        assert_kind_of IO, ep.to_io
-      end
-    end
-    assert ! @ep.closed?
-  end unless RBX
-
   def test_clone
     tmp = []
     clone = @ep.clone
@@ -259,7 +248,7 @@ class TestEpoll < Test::Unit::TestCase
     clone.add @wr, Epoll::OUT
     @ep.wait(nil, 0) { |flags, obj| tmp << [ flags, obj ] }
     assert_equal([[Epoll::OUT, @wr]], tmp)
-    assert_nothing_raised { clone.close }
+    clone.close
   end
 
   def test_dup
@@ -269,16 +258,14 @@ class TestEpoll < Test::Unit::TestCase
     clone.add @wr, Epoll::OUT
     @ep.wait(nil, 0) { |flags, obj| tmp << [ flags, obj ] }
     assert_equal([[Epoll::OUT, @wr]], tmp)
-    assert_nothing_raised { clone.close }
+    clone.close
   end
 
   def test_set_idempotency
-    assert_nothing_raised do
-      @ep.set @rd, Epoll::IN
-      @ep.set @rd, Epoll::IN
-      @ep.set @wr, Epoll::OUT
-      @ep.set @wr, Epoll::OUT
-    end
+    @ep.set @rd, Epoll::IN
+    @ep.set @rd, Epoll::IN
+    @ep.set @wr, Epoll::OUT
+    @ep.set @wr, Epoll::OUT
   end
 
   def test_wait_timeout
@@ -290,10 +277,8 @@ class TestEpoll < Test::Unit::TestCase
 
   def test_del
     assert_raises(Errno::ENOENT) { @ep.del(@rd) }
-    assert_nothing_raised do
-      @ep.add(@rd, Epoll::IN)
-      @ep.del(@rd)
-    end
+    @ep.add(@rd, Epoll::IN)
+    @ep.del(@rd)
   end
 
   def test_wait_read
@@ -368,7 +353,7 @@ class TestEpoll < Test::Unit::TestCase
   def test_delete
     assert_nil @ep.delete(@rd)
     assert_nil @ep.delete(@wr)
-    assert_nothing_raised { @ep.add @rd, Epoll::IN }
+    @ep.add @rd, Epoll::IN
     assert_equal @rd, @ep.delete(@rd)
     assert_nil @ep.delete(@rd)
   end
@@ -466,12 +451,12 @@ class TestEpoll < Test::Unit::TestCase
       trap(:USR1, "DEFAULT")
       sleep 0.1
       ppid = Process.ppid
-      nr.times { Process.kill(:USR1, ppid); sleep 0.01 }
+      nr.times { Process.kill(:USR1, ppid); sleep 0.05 }
       @wr.syswrite('.')
       exit!(0)
     end
     while tmp.empty?
-      assert_nothing_raised { @ep.wait(nil, 100) { |flags,obj| tmp << obj } }
+      @ep.wait(nil, 100) { |flags,obj| tmp << obj }
       empty += 1
     end
     _, status = Process.waitpid2(pid)
@@ -545,4 +530,4 @@ class TestEpoll < Test::Unit::TestCase
     end
     @ep.wait(1) { |flags, io| assert_equal(first[0], io) }
   end
-end
+end if defined?(SleepyPenguin::Epoll)