sleepy_penguin 1.0.0

data/sleepy_penguin.gemspec

@@ -0,0 +1,36 @@
+ENV["VERSION"] or abort "VERSION= must be specified"
+manifest = File.readlines('.manifest').map! { |x| x.chomp! }
+summary = File.readlines("README")[0].gsub(/\A=\s+\S+[^\w]+/, '').strip
+description = File.read("README").split(/\n\n/)[1].strip
+
+Gem::Specification.new do |s|
+  s.name = %q{sleepy_penguin}
+  s.version = ENV["VERSION"]
+
+  s.homepage = 'http://bogomips.org/sleepy_penguin/'
+  s.authors = ["sleepy_penguin hackers"]
+  s.date = Time.now.utc.strftime('%Y-%m-%d')
+  s.description = description
+  s.email = %q{sleepy.penguin@librelist.com}
+
+  s.extra_rdoc_files = File.readlines('.document').map! do |x|
+    x.chomp!
+    if File.directory?(x)
+      manifest.grep(%r{\A#{x}/})
+    elsif File.file?(x)
+      x
+    else
+      nil
+    end
+  end.flatten.compact
+
+  s.files = manifest
+  s.rdoc_options = [ "-t", summary ]
+  s.require_paths = %w(lib ext)
+  s.rubyforge_project = %q{rainbows}
+  s.summary = summary
+  s.test_files = Dir['test/test_*.rb']
+  s.extensions = %w(ext/sleepy_penguin/extconf.rb)
+
+  # s.license = %w(LGPL) # disabled for compatibility with older RubyGems
+end

data/test/test_epoll.rb

@@ -0,0 +1,320 @@
+require 'test/unit'
+require 'fcntl'
+require 'socket'
+$-w = true
+
+require 'sleepy_penguin'
+
+class TestEpoll < Test::Unit::TestCase
+  include SleepyPenguin
+  RBX = defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'rbx')
+
+  def setup
+    @rd, @wr = IO.pipe
+    @ep = Epoll.new
+  end
+
+  def teardown
+    [ @rd, @wr, @ep ].each { |io| io.close unless io.closed? }
+  end
+
+  def test_cross_thread
+    tmp = []
+    Thread.new { sleep 0.100; @ep.add(@wr, Epoll::OUT) }
+    t0 = Time.now
+    @ep.wait { |flags,obj| tmp << [ flags, obj ] }
+    elapsed = Time.now - t0
+    assert elapsed >= 0.100
+    assert_equal [[Epoll::OUT, @wr]], tmp
+  end
+
+  def test_fork_safe
+    tmp = []
+    @ep.add @rd, Epoll::IN
+    pid = fork do
+      @ep.wait(nil, 100) { |flags,obj| tmp << [ flags, obj ] }
+      exit!(tmp.empty?)
+    end
+    @wr.syswrite "HI"
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    @ep.wait(nil, 0) { |flags,obj| tmp << [ flags, obj ] }
+    assert_equal [[Epoll::IN, @rd]], tmp
+  end
+
+  def test_after_fork_usability
+    fork { @ep.add(@rd, Epoll::IN); exit!(0) }
+    fork { @ep.set(@rd, Epoll::IN); exit!(0) }
+    fork { @ep.to_io; exit!(0) }
+    fork { @ep.dup; exit!(0) }
+    fork { @ep.clone; exit!(0) }
+    fork { @ep.close; exit!(0) }
+    fork { @ep.closed?; exit!(0) }
+    fork {
+      begin
+        @ep.del(@rd)
+      rescue Errno::ENOENT
+        exit!(0)
+      end
+      exit!(1)
+    }
+    res = Process.waitall
+    res.each { |(pid,status)| assert status.success? }
+  end
+
+  def test_tcp_connect_nonblock_edge
+    epflags = Epoll::OUT | Epoll::ET
+    host = '127.0.0.1'
+    srv = TCPServer.new(host, 0)
+    port = srv.addr[1]
+    addr = Socket.pack_sockaddr_in(port, host)
+    sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+    assert_raises(Errno::EINPROGRESS) { sock.connect_nonblock(addr) }
+    IO.select(nil, [ sock ], [sock ])
+    @ep.add(sock, epflags)
+    tmp = []
+    @ep.wait(1) { |flags, obj| tmp << [ flags, obj ] }
+    assert_equal [ [Epoll::OUT,  sock] ], tmp
+  end
+
+  def test_tcp_connect_edge
+    epflags = Epoll::OUT | Epoll::ET
+    host = '127.0.0.1'
+    srv = TCPServer.new(host, 0)
+    port = srv.addr[1]
+    sock = TCPSocket.new(host, port)
+    @ep.add(sock, epflags)
+    tmp = []
+    @ep.wait(1) { |flags, obj| tmp << [ flags, obj ] }
+    assert_equal [ [Epoll::OUT,  sock] ], tmp
+  end
+
+  def teardown
+    assert_nothing_raised do
+      @rd.close unless @rd.closed?
+      @wr.close unless @wr.closed?
+      @ep.close unless @ep.closed?
+    end
+  end
+
+  def test_max_events_big
+    @ep.add @rd, Epoll::IN
+    tmp = []
+    thr = Thread.new { @ep.wait(1024) { |flags, obj| tmp << [ flags, obj ] } }
+    Thread.pass
+    assert tmp.empty?
+    @wr.write '.'
+    thr.join
+    assert_equal([[Epoll::IN, @rd]], tmp)
+    tmp.clear
+    thr = Thread.new { @ep.wait { |flags, obj| tmp << [ flags, obj ] } }
+    thr.join
+    assert_equal([[Epoll::IN, @rd]], tmp)
+  end
+
+  def test_max_events_small
+    @ep.add @rd, Epoll::IN | Epoll::ET
+    @ep.add @wr, Epoll::OUT | Epoll::ET
+    @wr.write '.'
+    tmp = []
+    @ep.wait(1) { |flags, obj| tmp << [ flags, obj ] }
+    assert_equal 1, tmp.size
+    @ep.wait(1) { |flags, obj| tmp << [ flags, obj ] }
+    assert_equal 2, tmp.size
+  end
+
+  def test_signal_safe
+    time = {}
+    trap(:USR1) { time[:USR1] = Time.now; sleep 0.1; @wr.write '.' }
+    @ep.add @rd, Epoll::IN
+    tmp = []
+    pid = fork do
+      sleep 0.1 # slightly racy :<
+      Process.kill(:USR1, Process.ppid)
+    end
+    time[:START_WAIT] = Time.now
+    @ep.wait { |flags, obj| tmp << [ flags, obj ]; time[:EP] = Time.now }
+    assert_equal([[Epoll::IN, @rd]], tmp)
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    assert((time[:USR1] - time[:START_WAIT]) >= 0.1)
+    assert((time[:USR1] - time[:START_WAIT]) < 0.15)
+    assert((time[:EP] - time[:USR1]) >= 0.1)
+    assert((time[:EP] - time[:USR1]) < 0.15)
+    ensure
+      trap(:USR1, 'DEFAULT')
+  end unless RBX
+
+  def test_close
+    @ep.add @rd, Epoll::IN
+    tmp = []
+    thr = Thread.new { @ep.wait { |flags, obj| tmp << [ flags, obj ] } }
+    @rd.close
+    @wr.close
+    assert_nil thr.join(0.01)
+    assert thr.alive?
+    thr.kill
+    assert tmp.empty?
+  end
+
+  def test_rdhup
+    rd, wr = UNIXSocket.pair
+    @ep.add rd, Epoll::RDHUP
+    tmp = []
+    thr = Thread.new { @ep.wait { |flags, obj| tmp << [ flags, obj ] } }
+    wr.shutdown Socket::SHUT_WR
+    thr.join
+    assert_equal([[ Epoll::RDHUP, rd ]], tmp)
+  end
+
+  def test_hup
+    @ep.add @rd, Epoll::IN
+    tmp = []
+    thr = Thread.new { @ep.wait { |flags, obj| tmp << [ flags, obj ] } }
+    @wr.close
+    thr.join
+    assert_equal([[ Epoll::HUP, @rd ]], tmp)
+  end
+
+  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
+    tmp = []
+    @ep.wait { |flags, obj| tmp << [ flags, obj ] }
+    assert_equal 2, tmp.size
+    assert_equal [ Epoll::OUT ], tmp.map { |flags, obj| flags }.uniq
+    ios = tmp.map { |flags, obj| obj }
+    assert ios.include?(@wr)
+    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
+        io = ep.to_io
+      end
+    end
+    assert ! @ep.closed?
+  end unless RBX
+
+  def test_clone
+    tmp = []
+    clone = @ep.clone
+    assert @ep.to_io.fileno != clone.to_io.fileno
+    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 }
+  end
+
+  def test_dup
+    tmp = []
+    clone = @ep.dup
+    assert @ep.to_io.fileno != clone.to_io.fileno
+    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 }
+  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
+  end
+
+  def test_wait_timeout
+    t0 = Time.now
+    assert_equal 0, @ep.wait(nil, 100) { |flags,obj| assert false }
+    diff = Time.now - t0
+    assert(diff >= 0.075, "#{diff} < 0.100s")
+  end
+
+  def test_del
+    assert_raises(Errno::ENOENT) { @ep.del(@rd) }
+    assert_nothing_raised do
+      @ep.add(@rd, Epoll::IN)
+      @ep.del(@rd)
+    end
+  end
+
+  def test_wait_read
+    @ep.add(@rd, Epoll::IN)
+    assert_equal 0, @ep.wait(nil, 0) { |flags,obj| assert false }
+    @wr.syswrite '.'
+    i = 0
+    nr = @ep.wait(nil, 0) do |flags,obj|
+      assert_equal Epoll::IN, flags
+      assert_equal obj, @rd
+      i += 1
+    end
+    assert_equal 1, i
+    assert_equal 1, nr
+  end
+
+  def test_wait_write
+    @ep.add(@wr, Epoll::OUT | Epoll::IN)
+    i = 0
+    nr = @ep.wait(nil, 0) do |flags, obj|
+      assert_equal Epoll::OUT, flags
+      assert_equal obj, @wr
+      i += 1
+    end
+    assert_equal 1, nr
+    assert_equal 1, i
+  end
+
+  def test_wait_write_blocked
+    begin
+      @wr.write_nonblock('.' * 65536)
+    rescue Errno::EAGAIN
+      break
+    end while true
+    @ep.add(@wr, Epoll::OUT | Epoll::IN)
+    i = 0
+    assert_equal 0, @ep.wait(nil, 0) { |flags,event| assert false }
+  end
+
+  def test_selectable
+    tmp = nil
+    @ep.add @rd, Epoll::IN
+    thr = Thread.new { tmp = IO.select([ @ep ]) }
+    thr.join 0.01
+    assert_nil tmp
+    @wr.write '.'
+    thr.join
+    assert_equal([[@ep],[],[]], tmp)
+  end
+
+  def test_new_no_cloexec
+    @ep.close
+    io = Epoll.new(0).to_io
+    assert((io.fcntl(Fcntl::F_GETFD) & Fcntl::FD_CLOEXEC) == 0)
+  end
+
+  def test_new_cloexec
+    @ep.close
+    io = Epoll.new(Epoll::CLOEXEC).to_io
+    assert((io.fcntl(Fcntl::F_GETFD) & Fcntl::FD_CLOEXEC) == Fcntl::FD_CLOEXEC)
+  end
+
+  def test_new
+    @ep.close
+    io = Epoll.new.to_io
+    assert((io.fcntl(Fcntl::F_GETFD) & Fcntl::FD_CLOEXEC) == Fcntl::FD_CLOEXEC)
+  end
+end

data/test/test_eventfd.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'fcntl'
+$-w = true
+
+require 'sleepy_penguin'
+
+class TestEventFD < Test::Unit::TestCase
+  include SleepyPenguin
+
+  def test_constants
+    defined?(EventFD::NONBLOCK) and
+      assert_kind_of Integer, EventFD::NONBLOCK
+    defined?(EventFD::CLOEXEC) and
+      assert_kind_of Integer, EventFD::CLOEXEC
+    defined?(EventFD::SEMAPHORE) and
+      assert_kind_of Integer, EventFD::SEMAPHORE
+  end
+
+  def test_new
+    efd = EventFD.new 0
+    assert_kind_of(IO, efd)
+  end
+
+  def test_new_nonblock
+    efd = EventFD.new(0, EventFD::NONBLOCK)
+    flags = efd.fcntl(Fcntl::F_GETFL) & Fcntl::O_NONBLOCK
+    assert_equal(Fcntl::O_NONBLOCK, flags)
+  end if defined?(EventFD::NONBLOCK)
+
+  def test_new_cloexec
+    efd = EventFD.new(0, EventFD::CLOEXEC)
+    flags = efd.fcntl(Fcntl::F_GETFD) & Fcntl::FD_CLOEXEC
+    assert_equal(Fcntl::FD_CLOEXEC, flags)
+  end if defined?(EventFD::CLOEXEC)
+
+  def test_incr_value
+    efd = EventFD.new(0)
+    assert_nil efd.incr(1)
+    assert_equal 1, efd.value
+
+    assert_raises(Errno::EAGAIN) { efd.value_nonblock }
+    assert_nil efd.incr(9)
+    assert_equal 9, efd.value_nonblock
+
+    assert_nil efd.incr(0xfffffffffffffffe)
+    assert_raises(Errno::EAGAIN) { efd.incr_nonblock 1 }
+  end
+end if defined?(SleepyPenguin::EventFD)

data/test/test_timerfd.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'fcntl'
+$-w = true
+
+require 'sleepy_penguin'
+
+class TestTimerFD < Test::Unit::TestCase
+  include SleepyPenguin
+
+  def test_constants
+    assert_kind_of Integer, TimerFD::REALTIME
+    assert_kind_of Integer, TimerFD::MONOTONIC
+  end
+
+  def test_create
+    tfd = TimerFD.create
+    assert_kind_of(IO, tfd)
+  end
+
+  def test_create_nonblock
+    tfd = TimerFD.create(TimerFD::REALTIME, TimerFD::NONBLOCK)
+    flags = tfd.fcntl(Fcntl::F_GETFL) & Fcntl::O_NONBLOCK
+    assert_equal(Fcntl::O_NONBLOCK, flags)
+  end if defined?(TimerFD::NONBLOCK)
+
+  def test_create_cloexec
+    tfd = TimerFD.create(TimerFD::REALTIME, TimerFD::CLOEXEC)
+    flags = tfd.fcntl(Fcntl::F_GETFD) & Fcntl::FD_CLOEXEC
+    assert_equal(Fcntl::FD_CLOEXEC, flags)
+  end if defined?(TimerFD::CLOEXEC)
+
+  def test_settime
+    tfd = TimerFD.create(TimerFD::REALTIME)
+    assert_equal([0, 0], tfd.settime(TimerFD::ABSTIME, 0, 0.01))
+    sleep 0.01
+    assert_equal 1, tfd.expirations
+  end
+end if defined?(SleepyPenguin::TimerFD)

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: sleepy_penguin
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- sleepy_penguin hackers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-26 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: |-
+  sleepy_penguin provides access to newer, Linux-only system calls to wait
+  on events from traditionally non-I/O sources.  Bindings to the eventfd,
+  timerfd, and epoll interfaces are provided.
+email: sleepy.penguin@librelist.com
+executables: []
+
+extensions: 
+- ext/sleepy_penguin/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README
+- TODO
+- NEWS
+- ChangeLog
+- lib/sleepy_penguin.rb
+- ext/sleepy_penguin/init.c
+- ext/sleepy_penguin/eventfd.c
+- ext/sleepy_penguin/timerfd.c
+files: 
+- .document
+- .gitignore
+- .manifest
+- COPYING
+- ChangeLog
+- GIT-VERSION-FILE
+- GIT-VERSION-GEN
+- GNUmakefile
+- LICENSE
+- NEWS
+- README
+- Rakefile
+- TODO
+- ext/sleepy_penguin/epoll.c
+- ext/sleepy_penguin/eventfd.c
+- ext/sleepy_penguin/extconf.rb
+- ext/sleepy_penguin/init.c
+- ext/sleepy_penguin/nonblock.h
+- ext/sleepy_penguin/sleepy_penguin.h
+- ext/sleepy_penguin/timerfd.c
+- ext/sleepy_penguin/value2timespec.h
+- lib/sleepy_penguin.rb
+- setup.rb
+- sleepy_penguin.gemspec
+- test/test_epoll.rb
+- test/test_eventfd.rb
+- test/test_timerfd.rb
+has_rdoc: true
+homepage: http://bogomips.org/sleepy_penguin/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- -t
+- Ruby I/O events for Linux
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rainbows
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby I/O events for Linux
+test_files: 
+- test/test_epoll.rb
+- test/test_eventfd.rb
+- test/test_timerfd.rb