yakischloba-ktools 0.0.2 → 0.0.3

data/README

@@ -16,27 +16,28 @@ Synopsis:
 #  irb(main):006:0> w.write "foo"
 #  => 3
 #  irb(main):007:0> kq.poll
-#  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :event=>:read}]
+#  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :events=>[:read]}]
 #  irb(main):008:0> [r, w, kq].each {|i| i.close}
 
 
 I plan to support the following kernel APIs:
 
 kqueue (works - see tests/test_kqueue.rb)
-epoll (works - see tests/test_epoll.rb. Needs Ruby wrapper.)
+epoll (works - see tests/test_epoll.rb)
 inotify
 netlink
 
 and maybe some others! I will at first hook up the C interfaces as directly 
-as possible, and then write Rubyist-friendly wrappers around them. Kqueue
-currently has a (I think) decent wrapper and epoll is up next.
+as possible, and then write Rubyist-friendly wrappers around them.
+
+Currently kqueue and epoll have Ruby wrapper APIs.
 
 
 To install:
 
 git clone git://github.com/yakischloba/ktools.git
 cd ktools
-gem build
+gem build ktools.gemspec
 sudo gem install ktools-<version>.gem
 
 Also gems are on Rubyforge, so you can simply 'sudo gem install ktools', but commits will

data/Rakefile

@@ -12,7 +12,6 @@ end
 task :config do
   $ktools_defines = []
   $ktools_dlext = RbConfig::expand(CONFIG['DLEXT'])
-  (add_define "HAVE_TBR" and build_against_ruby_stuff = true) if have_func('rb_thread_blocking_region')
   add_define "HAVE_KQUEUE" if have_header("sys/event.h") and have_header("sys/queue.h")
   #add_define "HAVE_INOTIFY" if inotify = have_func('inotify_init', 'sys/inotify.h')
   #add_define "HAVE_OLD_INOTIFY" if !inotify && have_macro('__NR_inotify_init', 'sys/syscall.h')
@@ -34,17 +33,10 @@ task :config do
   $ktools_srcs = ["ktools.c"]
   $ktools_srcs << "kqueue.c" if $ktools_defines.include?("-DHAVE_KQUEUE")
   $ktools_srcs << "inotify.c" if $ktools_defines.include?("-DHAVE_INOTIFY")
-  $ktools_srcs << "epoll.c" if $ktools_defines.include?("-DHAVE_EPOLL")
   $ktools_srcs << "netlink.c" if $ktools_defines.include?("-DHAVE_NETLINK")
 
-  if CONFIG["rubyhdrdir"]
-    hdrdir = RbConfig::expand(CONFIG["rubyhdrdir"])
-    $ktools_includes = "-I. -I#{hdrdir}/#{RbConfig::expand(CONFIG["sitearch"])} -I#{hdrdir}" if build_against_ruby_stuff
-  end
-
   $ktools_ldshared = RbConfig::expand(CONFIG['LDSHARED'])
   $ktools_ldshared << " -o ../lib/ktools.#{$ktools_dlext} " + $ktools_srcs.collect{|x| x.gsub(/\.c/, ".o")}.join(" ")
-  $ktools_ldshared << " -L#{RbConfig::expand(CONFIG['libdir'])} #{RbConfig::expand(CONFIG['LIBRUBYARG_SHARED'])}" if build_against_ruby_stuff
 end
 
 task :clean do
@@ -57,6 +49,7 @@ task :clean do
 end
 
 task :test do
+  require 'rubygems'
   require 'lib/ktools'
   require 'bacon'
   Bacon.summary_on_exit

data/ext/kqueue.c

@@ -2,38 +2,9 @@
 
 #include "kqueue.h"
 
-#ifdef HAVE_TBR
-#include <ruby.h>
-#endif
-
 void wrap_evset(struct kevent *kev, unsigned int ident, short filter, unsigned short flags, unsigned int fflags, int data, void *udata)
 {
 	EV_SET(kev, ident, filter, flags, fflags, data, udata);
 }
 
-int wrap_kevent(int kqfd, struct kevent *changelist, int nchanges, struct kevent *eventlist, int nevents, struct timespec *timeout)
-{
-  #ifdef HAVE_TBR
-  struct wrapped_kevent wevent;
-  wevent.kqfd = kqfd;
-  wevent.changelist = changelist;
-  wevent.nchanges = nchanges;
-  wevent.eventlist = eventlist;
-  wevent.nevents = nevents;
-  wevent.timeout = timeout;
-  wevent.result = -1;
-  rb_thread_blocking_region((rb_blocking_function_t *) tbr_kevent, &wevent, RUBY_UBF_IO, 0);
-  return wevent.result;
-  #else
-  return kevent(kqfd, changelist, nchanges, eventlist, nevents, timeout);
-  #endif
-}
-
-#ifdef HAVE_TBR
-void tbr_kevent(struct wrapped_kevent *wevent)
-{
-  wevent->result = kevent(wevent->kqfd, wevent->changelist, wevent->nchanges, wevent->eventlist, wevent->nevents, wevent->timeout);
-}
-#endif
-
 #endif

data/ext/kqueue.h

@@ -3,18 +3,4 @@
 #include <sys/event.h>
 #include <sys/queue.h>
 
-#ifdef HAVE_TBR
-struct wrapped_kevent {
-  int kqfd;
-  struct kevent *changelist;
-  int nchanges;
-  struct kevent *eventlist;
-  int nevents;
-  struct timespec *timeout;
-  int result;
-};
-
-void tbr_kevent(struct wrapped_kevent*);
-#endif
-
 #endif

data/ext/ktools.h

@@ -2,7 +2,7 @@
 #define KTOOLS_H
 
 #ifdef HAVE_EPOLL
-#include "epoll.h"
+#include <sys/epoll.h>
 #endif
 
 #ifdef HAVE_KQUEUE

data/ktools.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = "ktools"
-  s.version = "0.0.2"
-  s.date = "2009-04-22"
+  s.version = "0.0.3"
+  s.date = "2009-04-26"
   s.authors = ["Jake Douglas"]
   s.email = "jakecdouglas@gmail.com"
   s.rubyforge_project = "ktools"
@@ -22,8 +22,6 @@ Gem::Specification.new do |s|
     "lib/ktools/kqueue.rb",
     "ext/ktools.c",
     "ext/ktools.h",
-    "ext/epoll.c",
-    "ext/epoll.h",
     "ext/kqueue.c",
     "ext/kqueue.h",
     "tests/test_epoll.rb",

data/lib/ktools/epoll.rb

@@ -50,14 +50,14 @@ module Kernel
       :error => EPOLLERR
     }
 
+    # Missing in some kernel versions
     EP_FLAGS[:remote_hangup] = EPOLLRDHUP if const_defined?("EPOLLRDHUP")
 
     # Attach directly to epoll_create
     attach_function :epoll_create, [:int], :int
     # Attach directly to epoll_ctl
     attach_function :epoll_ctl, [:int, :int, :int, :pointer], :int
-    # Attach to the epoll_wait wrapper so we can use rb_thread_blocking_region when possible
-    attach_function :epoll_wait, :wrap_epoll_wait, [:int, :pointer, :int, :int], :int
+    attach_function :epoll_wait, [:int, :pointer, :int, :int], :int
 
     # Creates a new epoll event queue. Takes an optional size parameter (default 1024) that is a hint
     # to the kernel about how many descriptors it will be handling. Read man epoll_create for details 
@@ -66,6 +66,7 @@ module Kernel
       @fds = {}
       @epfd = epoll_create(size)
       raise SystemCallError.new("Error creating epoll descriptor", get_errno) unless @epfd > 0
+      @epfd = IO.for_fd(@epfd)
     end
 
     # Generic method for adding events. This simply calls the proper add_foo method specified by the type symbol.
@@ -115,7 +116,7 @@ module Kernel
     #  irb(main):006:0> w.write 'foo'
     #  => 3
     #  irb(main):007:0> ep.poll
-    #  => [{:target=>#<IO:0x89be38c>, :event=>:read, :type=>:socket}]
+    #  => [{:target=>#<IO:0x89be38c>, :events=>[:read], :type=>:socket}]
     #  irb(main):008:0> [r, w, ep].each{|x| x.close }
     def add_socket(target, options={})
       fdnum = target.respond_to?(:fileno) ? target.fileno : target
@@ -126,7 +127,7 @@ module Kernel
       ev[:data] = Epoll_data.new
       ev[:data][:fd] = fdnum
 
-      if epoll_ctl(@epfd, EPOLL_CTL_ADD, fdnum, ev) == -1
+      if epoll_ctl(@epfd.fileno, EPOLL_CTL_ADD, fdnum, ev) == -1
         return false
       else
         @fds[fdnum] = {:target => target, :event => ev}
@@ -136,12 +137,11 @@ module Kernel
 
     # Poll for an event. Pass an optional timeout float as number of seconds to wait for an event. Default is 0.0 (do not wait).
     #
-    # Using a timeout will block for the duration of the timeout. Under Ruby 1.9.1, we use rb_thread_blocking_region() under the
-    # hood to allow other threads to run during this call. Prior to 1.9 though, we do not have native threads and hence this call
-    # will block the whole interpreter (all threads) until it returns.
+    # Using a timeout will block the current thread for the duration of the timeout. We use select() on the epoll descriptor and
+    # then call epoll_wait() with 0 timeout, instead of blocking the whole interpreter with epoll_wait().
     #
     # This call returns an array of hashes, similar to the following:
-    #  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :event=>:read}]
+    #  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :events=>[:read]}]
     #
     # * :type - will be the type of event target, i.e. an event set with #add_socket will have :type => :socket
     # * :target - the 'target' or 'subject' of the event. This can be a File, IO, process or signal number.
@@ -149,38 +149,37 @@ module Kernel
     #
     # Note: even though epoll only supports :socket style descriptors, we keep :type for consistency with other APIs.
     def poll(timeout=0.0)
-      timeout = (timeout * 1000).to_i
       ev = Epoll_event.new
-      case epoll_wait(@epfd, ev, 1, timeout)
-      when -1
-        [errno]
-      when 0
-        []
+
+      r, w, e = IO.select([@epfd], nil, nil, timeout)
+
+      if r.nil? || r.empty?
+        return []
       else
-        [process_event(ev)]
+        case epoll_wait(@epfd.fileno, ev, 1, 0)
+        when -1
+          [errno]
+        when 0
+          []
+        else
+          [process_event(ev)]
+        end
       end
     end
 
     def process_event(ev) #:nodoc:
       h = @fds[ev[:data][:fd]]
       return nil if h.nil?
-
-      event = if ev[:events] & EPOLLIN == EPOLLIN
-        :read
-      elsif ev[:events] & EPOLLOUT == EPOLLOUT
-        :write
-      elsif ev[:events] & ERPOLLPRI == EPOLLPRI
-        :priority
-      elsif ev[:events] & EPOLLERR == EPOLLERR
-        :error
-      elsif ev[:events] & EPOLLHUP == EPOLLHUP
-        :hangup
-      elsif Epoll.const_defined?("EPOLLRDHUP") and ev[:events] & EPOLLRDHUP == EPOLLRDHUP
-        :remote_hangup
-      end
-
-      delete(:socket, h[:target]) if ev[:events] & EPOLLONESHOT == EPOLLONESHOT
-      {:target => h[:target], :event => event, :type => :socket}
+      events = []
+      events << :read if ev[:events] & EPOLLIN == EPOLLIN
+      events << :write if ev[:events] & EPOLLOUT == EPOLLOUT
+      events << :priority if ev[:events] & EPOLLPRI == EPOLLPRI
+      events << :error if ev[:events] & EPOLLERR == EPOLLERR
+      events << :hangup if ev[:events] & EPOLLHUP == EPOLLHUP
+      events << :remote_hangup if Epoll.const_defined?("EPOLLRDHUP") and ev[:events] & EPOLLRDHUP == EPOLLRDHUP
+      events << :oneshot if h[:event][:events] & EPOLLONESHOT == EPOLLONESHOT
+      delete(:socket, h[:target]) if events.include?(:oneshot) || events.include?(:hangup) || events.include?(:remote_hangup)
+      {:target => h[:target], :events => events, :type => :socket}
     end
 
     # Stop generating events for the given type and event target, ie:
@@ -191,12 +190,13 @@ module Kernel
       ident = target.respond_to?(:fileno) ? target.fileno : target
       h = @fds[ident]
       return false if h.nil?
-      epoll_ctl(@epfd, EPOLL_CTL_DEL, ident, h[:event])
+      epoll_ctl(@epfd.fileno, EPOLL_CTL_DEL, ident, h[:event])
+      @fds.delete(ident)
       return true
     end
 
     def close
-      IO.for_fd(@epfd).close
+      @epfd.close
     end
 
   end

data/lib/ktools/kqueue.rb

@@ -12,11 +12,6 @@ module Kernel
       :udata, :pointer
     end
 
-    class Timespec < FFI::Struct
-      layout :tv_sec, :long,
-        :tv_nsec, :long
-    end
-
     kqc = FFI::ConstGenerator.new do |c|
       c.include 'sys/event.h'
 
@@ -110,8 +105,7 @@ module Kernel
     attach_function :ev_set, :wrap_evset, [:pointer, :uint, :short, :ushort, :uint, :int, :pointer], :void
     # Attach directly to kqueue function, no wrapper needed
     attach_function :kqueue, [], :int
-    # We wrap kqueue and kevent because we use rb_thread_blocking_region when it's available in MRI
-    attach_function :kevent, :wrap_kevent, [:int, :pointer, :int, :pointer, :int, Timespec], :int
+    attach_function :kevent, [:int, :pointer, :int, :pointer, :int, :pointer], :int
 
     # We provide the raw C interface above. Now we OO-ify it.
 
@@ -121,6 +115,7 @@ module Kernel
       @pids = {}
       @kqfd = kqueue
       raise SystemCallError.new("Error creating kqueue descriptor", get_errno) unless @kqfd > 0
+      @kqfd = IO.for_fd(@kqfd)
     end
 
     # Generic method for adding events. This simply calls the proper add_foo method specified by the type symbol.
@@ -172,7 +167,7 @@ module Kernel
     #  irb(main):006:0> file.delete
     #  => #<File:/tmp/kqueue-test20090417-602-evm5wc-0>
     #  irb(main):007:0> kq.poll
-    #  => [{:type=>:file, :target=>#<File:/tmp/kqueue-test20090417-602-evm5wc-0>, :event=>:delete}]
+    #  => [{:type=>:file, :target=>#<File:/tmp/kqueue-test20090417-602-evm5wc-0>, :events=>[:delete]}]
     #  irb(main):008:0> file.close and kq.close 
     #  => nil
     def add_file(file, options={})
@@ -187,7 +182,7 @@ module Kernel
       fflags = fflags.inject(0){|m,i| m | KQ_FFLAGS[i] }
       ev_set(k, fdnum, EVFILT_VNODE, EV_ADD | flags, fflags, 0, nil)
 
-      if kevent(@kqfd, k, 1, nil, 0, nil) == -1
+      if kevent(@kqfd.fileno, k, 1, nil, 0, nil) == -1
         return false
       else
         @fds[fdnum] = {:target => file, :event => k}
@@ -220,7 +215,7 @@ module Kernel
     #  irb(main):006:0> w.write "foo"
     #  => 3
     #  irb(main):007:0> kq.poll
-    #  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :event=>:read}]
+    #  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :events=>[:read]}]
     #  irb(main):008:0> [r, w, kq].each {|i| i.close}
     def add_socket(target, options={})
       filters, flags = options.values_at :events, :flags
@@ -231,7 +226,7 @@ module Kernel
       k = Kevent.new
       ev_set(k, fdnum, filters, EV_ADD | flags, 0, 0, nil)
 
-      if kevent(@kqfd, k, 1, nil, 0, nil) == -1
+      if kevent(@kqfd.fileno, k, 1, nil, 0, nil) == -1
         return false
       else
         @fds[fdnum] = {:target => target, :event => k}
@@ -260,7 +255,7 @@ module Kernel
     #  irb(main):005:0> Process.kill('TERM', fpid)
     #  => 1
     #  irb(main):006:0> kq.poll.first
-    #  => {:event=>:exit, :type=>:process, :target=>616}
+    #  => {:events=>[:exit], :type=>:process, :target=>616}
     #
     def add_process(pid, options={})
       flags, fflags = options.values_at :flags, :events
@@ -270,7 +265,7 @@ module Kernel
       k = Kevent.new
       ev_set(k, pid, EVFILT_PROC, EV_ADD | flags, fflags, 0, nil)
 
-      if kevent(@kqfd, k, 1, nil, 0, nil) == -1
+      if kevent(@kqfd.fileno, k, 1, nil, 0, nil) == -1
         return false
       else
         @pids[pid] = {:target => pid, :event => k}
@@ -280,29 +275,31 @@ module Kernel
 
     # Poll for an event. Pass an optional timeout float as number of seconds to wait for an event. Default is 0.0 (do not wait).
     #
-    # Using a timeout will block for the duration of the timeout. Under Ruby 1.9.1, we use rb_thread_blocking_region() under the
-    # hood to allow other threads to run during this call. Prior to 1.9 though, we do not have native threads and hence this call
-    # will block the whole interpreter (all threads) until it returns.
+    # Using a timeout will block the current thread for the duration of the timeout. We use select() on the kqueue descriptor and
+    # then call kevent() with 0 timeout, instead of blocking the whole interpreter with kevent().
     #
     # This call returns an array of hashes, similar to the following:
-    #  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :event=>:read}]
+    #  => [{:type=>:socket, :target=>#<IO:0x4fa90c>, :events=>[:read]}]
     #
     # * :type - will be the type of event target, i.e. an event set with #add_file will have :type => :file
     # * :target - the 'target' or 'subject' of the event. This can be a File, IO, process or signal number.
     # * :event - the event that occurred on the target. This is one of the symbols you passed as :events => [:foo] when adding the event.
     def poll(timeout=0.0)
       k = Kevent.new
-      t = Timespec.new
-      t[:tv_sec] = timeout.to_i
-      t[:tv_nsec] = ((timeout - timeout.to_i) * 1e9).to_i
-
-      case kevent(@kqfd, nil, 0, k, 1, t)
-      when -1
-        [errno]
-      when 0
-        []
+
+      r, w, e = IO.select([@kqfd], nil, nil, timeout)
+
+      if r.nil? || r.empty?
+        return []
       else
-        [process_event(k)]
+        case kevent(@kqfd.fileno, nil, 0, k, 1, nil)
+        when -1
+          [errno]
+        when 0
+          []
+        else
+          [process_event(k)]
+        end
       end
     end
 
@@ -311,47 +308,35 @@ module Kernel
       when EVFILT_VNODE
         h = @fds[k[:ident]]
         return nil if h.nil?
-        event = if k[:fflags] & NOTE_DELETE == NOTE_DELETE
-          :delete
-        elsif k[:fflags] & NOTE_WRITE == NOTE_WRITE
-          :write
-        elsif k[:fflags] & NOTE_EXTEND == NOTE_EXTEND
-          :extend
-        elsif k[:fflags] & NOTE_ATTRIB == NOTE_ATTRIB
-          :attrib
-        elsif k[:fflags] & NOTE_LINK == NOTE_LINK
-          :link
-        elsif k[:fflags] & NOTE_RENAME == NOTE_RENAME
-          :rename
-        elsif k[:fflags] & NOTE_REVOKE == NOTE_REVOKE
-          :revoke
-        end
-        delete(:file, k[:ident]) if event == :delete || event == :revoke
-        {:target => h[:target], :type => :file, :event => event}
+        events = []
+        events << :delete if k[:fflags] & NOTE_DELETE == NOTE_DELETE
+        events << :write if k[:fflags] & NOTE_WRITE == NOTE_WRITE
+        events << :extend if k[:fflags] & NOTE_EXTEND == NOTE_EXTEND
+        events << :attrib if k[:fflags] & NOTE_ATTRIB == NOTE_ATTRIB
+        events << :link if k[:fflags] & NOTE_LINK == NOTE_LINK
+        events << :rename if k[:fflags] & NOTE_RENAME == NOTE_RENAME
+        events << :revoke if k[:fflags] & NOTE_REVOKE == NOTE_REVOKE
+        delete(:file, k[:ident]) if events.include?(:delete) || events.include?(:revoke)
+        {:target => h[:target], :type => :file, :events => events}
       when EVFILT_READ
         h = @fds[k[:ident]]
         return nil if h.nil?
-        {:target => h[:target], :type => :socket, :event => :read}
+        {:target => h[:target], :type => :socket, :events => [:read]}
       when EVFILT_WRITE
         h = @fds[k[:ident]]
         return nil if h.nil?
-        {:target => h[:target], :type => :socket, :event => :write}
+        {:target => h[:target], :type => :socket, :events => [:write]}
       when EVFILT_PROC
         h = @pids[k[:ident]]
         return nil if h.nil?
-        event = if k[:fflags] & NOTE_EXIT == NOTE_EXIT
-          :exit
-        elsif k[:fflags] & NOTE_FORK == NOTE_FORK
-          :fork
-        elsif k[:fflags] & NOTE_EXEC == NOTE_EXEC
-          :exec
-        elsif Kqueue.const_defined?("NOTE_SIGNAL") and k[:fflags] & NOTE_SIGNAL == NOTE_SIGNAL
-          :signal
-        elsif Kqueue.const_defined?("NOTE_REAP") and k[:fflags] & NOTE_REAP == NOTE_REAP
-          :reap
-        end
-        delete(:process, k[:ident]) if event == :exit
-        {:target => h[:target], :type => :process, :event => event}
+        events = []
+        events << :exit if k[:fflags] & NOTE_EXIT == NOTE_EXIT
+        events << :fork if k[:fflags] & NOTE_FORK == NOTE_FORK
+        events << :exec if k[:fflags] & NOTE_EXEC == NOTE_EXEC
+        events << :signal if Kqueue.const_defined?("NOTE_SIGNAL") and k[:fflags] & NOTE_SIGNAL == NOTE_SIGNAL
+        events << :reap if Kqueue.const_defined?("NOTE_REAP") and k[:fflags] & NOTE_REAP == NOTE_REAP
+        delete(:process, k[:ident]) if events.include?(:exit)
+        {:target => h[:target], :type => :process, :events => events}
       end
 
       delete(res[:type], res[:target]) if k[:flags] & EV_ONESHOT == EV_ONESHOT
@@ -374,14 +359,14 @@ module Kernel
       return false if h.nil?
       k = h[:event]
       ev_set(k, k[:ident], k[:filter], EV_DELETE, k[:fflags], 0, nil)
-      kevent(@kqfd, k, 1, nil, 0, nil)
+      kevent(@kqfd.fileno, k, 1, nil, 0, nil)
       container.delete(ident)
       return true
     end
 
     # Close the kqueue descriptor. This essentially shuts down your kqueue and renders all active events on this kqueue removed. 
     def close
-      IO.for_fd(@kqfd).close
+      @kqfd.close
     end
 
   end

data/tests/test_epoll.rb

@@ -44,7 +44,7 @@ describe "the epoll interface" do
     w.write 'foo'
     res = ep.poll.first
 
-    res[:event].should.equal :read
+    res[:events].should.include :read
     res[:target].fileno.should.equal r.fileno
     res[:type].should.equal :socket
 
@@ -65,5 +65,24 @@ describe "the epoll interface" do
 
     [r,w,ep].each{|i| i.close}
   end
+  
+  it "should provide aggregated events on a target" do
+    r, w = IO.pipe
+    ep = Epoll.new
+
+    ep.add(:socket, r, :events => [:read, :hangup]).should.be.true
+    ep.poll.should.be.empty
+
+    w.write 'foo'
+    w.close
+
+    res = ep.poll.first
+    res[:type].should.equal :socket
+    res[:target].fileno.should.equal r.fileno
+    res[:events].should.include :read
+    res[:events].should.include :hangup
+
+    [r, ep].each{|i| i.close}
+  end
 
 end

data/tests/test_kqueue.rb

@@ -42,7 +42,7 @@ describe "the kqueue interface" do
     res[:target].class.should.equal Tempfile
     res[:target].fileno.should.equal file.fileno
     res[:type].should.equal :file
-    res[:event].should.equal :write
+    res[:events].should.include :write
 
     kq.poll.should.be.empty
     file.delete
@@ -51,7 +51,7 @@ describe "the kqueue interface" do
     res2[:target].class.should.equal Tempfile
     res2[:target].fileno.should.equal file.fileno
     res2[:type].should.equal :file
-    res2[:event].should.equal :delete
+    res2[:events].should.include :delete
 
     file.close
     kq.close
@@ -69,7 +69,7 @@ describe "the kqueue interface" do
     res[:target].class.should.equal IO
     res[:target].fileno.should.equal r.fileno
     res[:type].should.equal :socket
-    res[:event].should.equal :read
+    res[:events].should.include :read
 
     kq.poll.should.be.empty
     kq.delete(:socket, r).should.be.true
@@ -89,7 +89,7 @@ describe "the kqueue interface" do
     res = kq.poll(1).first
     res[:target].should.equal Process.pid
     res[:type].should.equal :process
-    res[:event].should.equal :fork
+    res[:events].should.include :fork
 
     # Watch for the child to exit and kill it
     kq.add(:process, fpid, :events => [:exit])
@@ -99,11 +99,32 @@ describe "the kqueue interface" do
     res2 = kq.poll(1).first
     res2[:target].should.equal fpid
     res2[:type].should.equal :process
-    res2[:event].should.equal :exit
+    res2[:events].should.include :exit
 
     kq.poll.should.be.empty
 
     kq.close
   end
 
+  it "should provide aggregated events on a single target" do
+    file = Tempfile.new("kqueue-test")
+    kq = Kqueue.new
+    kq.add(:file, file, :events => [:write, :delete]).should.be.true
+
+    kq.poll.should.be.empty
+    File.open(file.path, 'w'){|x| x.puts 'foo'}
+    file.delete
+
+    res = kq.poll.first
+    res.class.should.equal Hash
+    res[:target].class.should.equal Tempfile
+    res[:target].fileno.should.equal file.fileno
+    res[:type].should.equal :file
+    res[:events].should.include :write
+    res[:events].should.include :delete
+
+    file.close
+    kq.close
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: yakischloba-ktools
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Jake Douglas
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-22 00:00:00 -07:00
+date: 2009-04-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,8 +50,6 @@ files:
 - lib/ktools/kqueue.rb
 - ext/ktools.c
 - ext/ktools.h
-- ext/epoll.c
-- ext/epoll.h
 - ext/kqueue.c
 - ext/kqueue.h
 - tests/test_epoll.rb

data/ext/epoll.c

@@ -1,32 +0,0 @@
-#ifdef HAVE_EPOLL
-
-#include "epoll.h"
-
-#ifdef HAVE_TBR
-#include <ruby.h>
-#endif
-
-int wrap_epoll_wait(int epfd, struct epoll_event *event, int maxevents, int timeout)
-{
-  #ifdef HAVE_TBR
-  struct wrapped_epoll_event epevent;
-  epevent.epfd = epfd;
-  epevent.event = event;
-  epevent.maxevents = maxevents;
-  epevent.timeout = timeout;
-  epevent.result = -1;
-  rb_thread_blocking_region((rb_blocking_function_t *) tbr_epoll_wait, &epevent, RUBY_UBF_IO, 0);
-  return epevent.result;
-  #else
-  return epoll_wait(epfd, event, maxevents, timeout);
-  #endif
-}
-
-#ifdef HAVE_TBR
-void tbr_epoll_wait(struct wrapped_epoll_event *event)
-{
-  event->result = epoll_wait(event->epfd, event->event, event->maxevents, event->timeout);
-}
-#endif
-
-#endif

data/ext/epoll.h

@@ -1,17 +0,0 @@
-#ifdef HAVE_EPOLL
-
-#include <sys/epoll.h>
-
-#ifdef HAVE_TBR
-struct wrapped_epoll_event {
-  int epfd;
-  struct epoll_event *event;
-  int maxevents;
-  int timeout;
-  int result;
-};
-
-void tbr_epoll_wait(struct wrapped_epoll_event*);
-#endif
-
-#endif