sleepy_penguin 3.1.0 → 3.1.0.26.g7181

data/ext/sleepy_penguin/timerfd.c

@@ -26,16 +26,16 @@ static VALUE s_new(int argc, VALUE *argv, VALUE klass)
 	int fd;
 
 	rb_scan_args(argc, argv, "02", &cid, &fl);
-	clockid = NIL_P(cid) ? CLOCK_MONOTONIC : rb_sp_get_flags(klass, cid);
-	flags = rb_sp_get_flags(klass, fl);
+	clockid = NIL_P(cid) ? CLOCK_MONOTONIC : rb_sp_get_flags(klass, cid, 0);
+	flags = rb_sp_get_flags(klass, fl, RB_SP_CLOEXEC(TFD_CLOEXEC));
 
 	fd = timerfd_create(clockid, flags);
-	if (fd == -1) {
+	if (fd < 0) {
 		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
 			rb_gc();
 			fd = timerfd_create(clockid, flags);
 		}
-		if (fd == -1)
+		if (fd < 0)
 			rb_sys_fail("timerfd_create");
 	}
 
@@ -66,13 +66,13 @@ static VALUE itimerspec2ary(struct itimerspec *its)
 static VALUE settime(VALUE self, VALUE fl, VALUE interval, VALUE value)
 {
 	int fd = rb_sp_fileno(self);
-	int flags = rb_sp_get_flags(self, fl);
+	int flags = rb_sp_get_flags(self, fl, 0);
 	struct itimerspec old, new;
 
 	value2timespec(&new.it_interval, interval);
 	value2timespec(&new.it_value, value);
 
-	if (timerfd_settime(fd, flags, &new, &old) == -1)
+	if (timerfd_settime(fd, flags, &new, &old) < 0)
 		rb_sys_fail("timerfd_settime");
 
 	return itimerspec2ary(&old);
@@ -89,7 +89,7 @@ static VALUE gettime(VALUE self)
 	int fd = rb_sp_fileno(self);
 	struct itimerspec curr;
 
-	if (timerfd_gettime(fd, &curr) == -1)
+	if (timerfd_gettime(fd, &curr) < 0)
 		rb_sys_fail("timerfd_gettime");
 
 	return itimerspec2ary(&curr);
@@ -126,10 +126,10 @@ static VALUE expirations(int argc, VALUE *argv, VALUE self)
 		blocking_io_prepare(fd);
 retry:
 	r = (ssize_t)rb_sp_fd_region(tfd_read, &buf, fd);
-	if (r == -1) {
+	if (r < 0) {
 		if (errno == EAGAIN && RTEST(nonblock))
 			return Qnil;
-		if (rb_io_wait_readable(fd = rb_sp_fileno(self)))
+		if (rb_sp_wait(rb_io_wait_readable, self, &fd))
 			goto retry;
 		rb_sys_fail("read(timerfd)");
 	}

data/ext/sleepy_penguin/util.c

@@ -5,10 +5,10 @@ static VALUE klass_for(VALUE klass)
 	return (TYPE(klass) == T_CLASS) ? klass : CLASS_OF(klass);
 }
 
-int rb_sp_get_flags(VALUE klass, VALUE flags)
+int rb_sp_get_flags(VALUE klass, VALUE flags, int default_flags)
 {
 	switch (TYPE(flags)) {
-	case T_NIL: return 0;
+	case T_NIL: return default_flags;
 	case T_FIXNUM: return FIX2INT(flags);
 	case T_BIGNUM: return NUM2INT(flags);
 	case T_SYMBOL:
@@ -123,21 +123,25 @@ void rb_sp_set_nonblock(int fd)
 		rb_sys_fail("fcntl(F_GETFL)");
 	if ((flags & O_NONBLOCK) == O_NONBLOCK)
 		return;
+	/*
+	 * Note: while this is Linux-only and we could safely rely on
+	 * ioctl(FIONBIO), needing F_SETFL is an uncommon path, and
+	 * F_GETFL is lockless.  ioctl(FIONBIO) always acquires a spin
+	 * lock, so it's more expensive even if we do not need to change
+	 * anything.
+	 */
 	flags = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-	if (flags == -1)
+	if (flags < 0)
 		rb_sys_fail("fcntl(F_SETFL)");
 }
 
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
-#include <rubysig.h>
-VALUE rb_sp_io_region(rb_blocking_function_t *func, void *data)
+int rb_sp_wait(rb_sp_waitfn waiter, VALUE obj, int *fd)
 {
-	VALUE rv;
-
-	TRAP_BEG;
-	rv = func(data);
-	TRAP_END;
-
-	return rv;
+	/*
+	 * we need to check the fileno before and after waiting, a close()
+	 * could've happened at any time (especially when outside of GVL).
+	 */
+	int rc = waiter(rb_sp_fileno(obj));
+	*fd = rb_sp_fileno(obj);
+	return rc;
 }
-#endif

data/lib/sleepy_penguin.rb

@@ -5,3 +5,19 @@ module SleepyPenguin
   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
+if defined?(SleepyPenguin::Inotify) &&
+   defined?(Rubinius) && Rubinius.respond_to?(:synchronize)
+  class SleepyPenguin::Inotify
+    # :stopdoc:
+    alias __take take
+    undef_method :take
+    def take(*args)
+      Rubinius.synchronize(@inotify_tmp) { __take(*args) }
+    end
+    # :startdoc
+  end
+end

data/lib/sleepy_penguin/epoll.rb

@@ -0,0 +1,264 @@
+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)
+    @mtx = Mutex.new
+    @events = []
+    @marks = []
+    @pid = $$
+    @create_flags = create_flags
+    @copies = { @to_io => self }
+  end
+
+  def __ep_reinit # :nodoc:
+    @events.clear
+    @marks.clear
+    @to_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?
+    objects = @copies.values
+    @copies.each_key { |epio| epio.close }
+    @copies.clear
+    __ep_reinit
+    objects.each do |obj|
+      io_dup = @to_io.dup
+      @copies[io_dup] = obj
+    end
+    @pid = $$
+  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
+  # threads.  Larger +maxevents+ reduces syscall overhead for
+  # single-threaded applications. +maxevents+ defaults to 64 events.
+  # +timeout+ is specified in milliseconds, +nil+
+  # (the default) meaning it will block and wait indefinitely.
+  def wait(maxevents = 64, timeout = nil)
+    # snapshot the marks so we do can sit this thread on epoll_wait while other
+    # threads may call epoll_ctl.  People say RCU is a poor man's GC, but our
+    # (ab)use of GC here is inspired by RCU...
+    snapshot = @mtx.synchronize do
+      __ep_check
+      @marks.dup
+    end
+
+    # 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) }
+  ensure
+    # hopefully Ruby does not optimize this array away...
+    snapshot[0]
+  end
+
+  # Starts watching a given +io+ object with +events+ which may be an Integer
+  # bitmask or Array representing arrays to watch for.
+  def add(io, events)
+    fd = io.to_io.fileno
+    events = __event_flags(events)
+    @mtx.synchronize do
+      __ep_check
+      @to_io.epoll_ctl(CTL_ADD, io, events)
+      @events[fd] = events
+      @marks[fd] = io
+    end
+    0
+  end
+
+  # call-seq:
+  #     ep.del(io) -> 0
+  #
+  # Disables an IO object from being watched.
+  def del(io)
+    fd = io.to_io.fileno
+    @mtx.synchronize do
+      __ep_check
+      @to_io.epoll_ctl(CTL_DEL, io, 0)
+      @events[fd] = @marks[fd] = nil
+    end
+    0
+  end
+
+  # call-seq:
+  #     ep.delete(io) -> io or nil
+  #
+  # This method is deprecated and will be removed in sleepy_penguin 4.x
+  #
+  # Stops an +io+ object from being monitored.  This is like Epoll#del
+  # but returns +nil+ on ENOENT instead of raising an error.  This is
+  # useful for apps that do not care to track the status of an
+  # epoll object itself.
+  #
+  # This method is deprecated and will be removed in sleepy_penguin 4.x
+  def delete(io)
+    fd = io.to_io.fileno
+    @mtx.synchronize do
+      __ep_check
+      cur_io = @marks[fd]
+      return if nil == cur_io || cur_io.to_io.closed?
+      @to_io.epoll_ctl(CTL_DEL, io, 0)
+      @events[fd] = @marks[fd] = nil
+    end
+    io
+  rescue Errno::ENOENT, Errno::EBADF
+  end
+
+  # call-seq:
+  #     epoll.mod(io, flags) -> 0
+  #
+  # Changes the watch for an existing IO object based on +events+.
+  # Returns zero on success, will raise SystemError on failure.
+  def mod(io, events)
+    events = __event_flags(events)
+    fd = io.to_io.fileno
+    @mtx.synchronize do
+      __ep_check
+      @to_io.epoll_ctl(CTL_MOD, io, events)
+      @marks[fd] = io # may be a different object with same fd/file
+      @events[fd] = events
+    end
+  end
+
+  # call-seq:
+  #     ep.set(io, flags) -> 0
+  #
+  # This method is deprecated and will be removed in sleepy_penguin 4.x
+  #
+  # Used to avoid exceptions when your app is too lazy to check
+  # what state a descriptor is in, this sets the epoll descriptor
+  # to watch an +io+ with the given +events+
+  #
+  # +events+ may be an array of symbols or an unsigned Integer bit mask:
+  #
+  # - events = [ :IN, :ET ]
+  # - events = SleepyPenguin::Epoll::IN | SleepyPenguin::Epoll::ET
+  #
+  # See constants in Epoll for more information.
+  #
+  # This method is deprecated and will be removed in sleepy_penguin 4.x
+  def set(io, events)
+    fd = io.to_io.fileno
+    @mtx.synchronize do
+      __ep_check
+      cur_io = @marks[fd]
+      if cur_io == io
+        cur_events = @events[fd]
+        return 0 if (cur_events & ONESHOT) == 0 && cur_events == events
+        begin
+          @to_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)
+          @marks[fd] = io
+        end
+      else
+        begin
+          @to_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)
+        end
+        @marks[fd] = io
+      end
+      @events[fd] = events
+    end
+    0
+  end
+
+  # call-seq:
+  #     ep.close -> nil
+  #
+  # Closes an existing Epoll object and returns memory back to the kernel.
+  # Raises IOError if object is already closed.
+  def close
+    @mtx.synchronize do
+      @copies.delete(@to_io)
+      @to_io.close
+    end
+  end
+
+  # call-seq:
+  #     ep.closed? -> true or false
+  #
+  # Returns whether or not an Epoll object is closed.
+  def closed?
+    @mtx.synchronize do
+      @to_io.closed?
+    end
+  end
+
+  # we still support integer FDs for some debug functions
+  def __fileno(io) # :nodoc:
+    Integer === io ? io : io.to_io.fileno
+  end
+
+  # call-seq:
+  #     ep.io_for(io) -> object
+  #
+  # Returns the given IO object currently being watched for.  Different
+  # IO objects may internally refer to the same process file descriptor.
+  # Mostly used for debugging.
+  def io_for(io)
+    fd = __fileno(io)
+    @mtx.synchronize do
+      __ep_check
+      @marks[fd]
+    end
+  end
+
+  # call-seq:
+  #     epoll.events_for(io) -> Integer
+  #
+  # Returns the events currently watched for in current Epoll object.
+  # Mostly used for debugging.
+  def events_for(io)
+    fd = __fileno(io)
+    @mtx.synchronize do
+      __ep_check
+      @events[fd]
+    end
+  end
+
+  # backwards compatibility, to be removed in 4.x
+  alias flags_for events_for
+
+  # call-seq:
+  #     epoll.include?(io) -> true or false
+  #
+  # Returns whether or not a given IO is watched and prevented from being
+  # garbage-collected by the current Epoll object.  This may include
+  # closed IO objects.
+  def include?(io)
+    fd = __fileno(io)
+    @mtx.synchronize do
+      __ep_check
+      @marks[fd] ? true : false
+    end
+  end
+
+  def initialize_copy(src) # :nodoc:
+    @mtx.synchronize do
+      __ep_check
+      rv = super
+      unless @to_io.closed?
+        @to_io = @to_io.dup
+        @copies[@to_io] = self
+      end
+      rv
+    end
+  end
+end

data/lib/sleepy_penguin/epoll/io.rb

@@ -0,0 +1,28 @@
+class SleepyPenguin::Epoll::IO
+  # :stopdoc:
+  alias __epoll_wait epoll_wait
+  undef_method :epoll_wait
+  def epoll_wait(maxevents = 64, timeout = nil)
+    begin
+      if timeout == nil || timeout < 0 # wait forever
+        begin
+          IO.select([self])
+          n = __epoll_wait(maxevents, 0) { |events,io| yield(events, io) }
+        end while n == 0
+      elsif timeout == 0
+        return __epoll_wait(maxevents, 0) { |events,io| yield(events, io) }
+      else
+        done = Time.now + (timeout / 1000.0)
+        begin
+          tout = done - Time.now
+          IO.select([self], nil, nil, tout) if tout > 0
+          n = __epoll_wait(maxevents, 0) { |events,io| yield(events, io) }
+        end while n == 0 && tout > 0
+      end
+      n
+    rescue Errno::EINTR
+      retry
+    end
+  end
+  # :startdoc:
+end

data/lib/sleepy_penguin/sp.rb

@@ -1,4 +1,4 @@
 # :stopdoc:
 require "sleepy_penguin"
-SP = SleepyPenguin
+Object.const_set(:SP, SleepyPenguin)
 # :startdoc:

data/sleepy_penguin.gemspec

@@ -9,13 +9,11 @@ Gem::Specification.new do |s|
   s.version = ENV["VERSION"].dup
   s.homepage = Wrongdoc.config[:rdoc_url]
   s.authors = ["#{name} hackers"]
-  s.date = Time.now.utc.strftime('%Y-%m-%d')
   s.description = readme_description
   s.email = %q{sleepy.penguin@librelist.org}
   s.extra_rdoc_files = extra_rdoc_files(manifest)
   s.files = manifest
   s.rdoc_options = rdoc_options
-  s.require_paths = %w(lib ext)
   s.rubyforge_project = %q{rainbows}
   s.summary = summary
   s.test_files = Dir['test/test_*.rb']
@@ -23,5 +21,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency('wrongdoc', '~> 1.5')
   s.add_development_dependency('strace_me', '~> 1.0')
 
-  # s.license = %w(LGPL) # disabled for compatibility with older RubyGems
+  s.licenses = %w(LGPLv2.1 LGPLv3)
 end