kqueue 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06a7b8bdf52804dcef98ac5f11bcf3164ef7d334
+  data.tar.gz: d0151bed17fd2237b52b9d556c999e1005a3704e
+SHA512:
+  metadata.gz: cc8b761373f7eb7228e4c1917112bf984c43dc4e31a7e99c649013b419e633535818d9a93692dd3884e5fb017bb11346c758447bb7a16f5c33a5cef6d3b159cb
+  data.tar.gz: 1ec0ad58c3c8f5c748c2d4d94d32a18444736299809ad47a60b065527a697b6797cfb6cf3a23bb741bc1d3138e1d9ab84295ece794073dc23f9e024df652d73d

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+*.rbc
+*.bundle
+*.so
+*.o
+tmp
+pkg

data/.travis.yml

@@ -0,0 +1,7 @@
+language: objective-c # osx hack
+rvm:
+  - 2.1.5
+os:
+  - osx
+script:
+  - "bundle exec rake clean compile test"

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    kqueue (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    power_assert (0.2.2)
+    rake (10.4.0)
+    rake-compiler (0.9.3)
+      rake
+    test-unit (3.0.7)
+      power_assert
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  kqueue!
+  rake
+  rake-compiler
+  test-unit

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 ksss
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+kqueue
+===
+
+[![Build Status](https://travis-ci.org/ksss/kqueue.svg?branch=master)](https://travis-ci.org/ksss/kqueue)
+
+A binding of kqueue on Ruby.
+
+**kqueue** can use BSD system only. (because must be installed sys/event.h)
+
+# Usage
+
+```ruby
+require 'kqueue'
+
+# Inheritance
+# class Kqueue < IO
+#   # ident: file descriptor identifier for this event
+#   # filter: filter for event(just one)
+#   # flags: general flags(complex fragment)
+#   # fflags: filter-specific flags(complex fragment)
+#   # data: filter-specific data
+#   # udata: opaque user data(can set any object)
+#   class Event < Struct.new(:ident, :filter, :flags, :fflags, :data, :udata)
+#     # Event::Constants include all kqueue constants
+#     include Event::Constants
+#   end
+# end
+
+# create kqueue object and ensure close
+Kqueue.open do |kq|
+  # ...
+end
+
+# or
+begin
+  kq = Kqueue.new
+  # ...
+ensure
+  kq.close
+end
+
+# watch event
+IO.pipe do |r, w|
+  Kqueue.open do |kq|
+    kev = Kqueue::Event.new(r.fileno, EVFILT_READ, EV_ADD, 0, 0, proc {
+      puts "you can read #{r.fileno} with non block!"
+    })
+    # set a event
+    kq.kevent([kev], 0)
+
+    # wait a event
+    # wait until event occur
+    kq.kevent(nil, 1)
+
+    # wait 0.1 sec
+    kq.kevent(nil, 1, 0.1) #=> []
+
+    w.write 'ok go'
+    w.flush
+
+    # get a notified event
+    kevs = kq.kevent(nil, 1) #=> [#<a Event object>]
+
+    # udata have one any object
+    kevs.first.udata.call #=> you can read 7 with non block!
+  end
+end
+```
+
+## filter
+
+filter|description
+---|---
+EVFILT_READ|on read
+EVFILT_WRITE|on write
+EVFILT_AIO|attached to aio requests
+EVFILT_VNODE|attached to vnodes
+EVFILT_PROC|attached to struct proc
+EVFILT_SIGNAL|attached to signal
+EVFILT_TIMER|timers
+EVFILT_MACHPORT|Mach portsets
+
+## flags
+
+flags|description
+---|---
+EV_ADD|add event to kq (implies enable)
+EV_DELETE|delete event from kq
+EV_ENABLE|enable event
+EV_DISABLE|disable event (not reported)
+EV_ONESHOT|only report one occurrence
+EV_CLEAR|clear event state after reporting
+EV_RECEIPT|force EV_ERROR on success, data == 0
+EV_ERROR|error, data contains errno(returned value)
+EV_EOF|EOF detected(returned value)
+
+# fflags
+
+fflags|description
+---|---
+NOTE_DELETE|vnode was removed
+NOTE_WRITE|data contents changed
+NOTE_EXTEND|size increased
+NOTE_ATTRIB|attributes changed
+NOTE_LINK|link count changed
+NOTE_RENAME|vnode was renamed
+NOTE_REVOKE|vnode access was revoked
+NOTE_EXIT|process exited
+NOTE_EXITSTATUS|exit status to be returned, valid for child process only
+NOTE_FORK|process forked
+NOTE_EXEC|process exec'd
+NOTE_SIGNAL|shared with EVFILT_SIGNAL
+NOTE_REAP|process reaped
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kqueue'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kqueue
+
+# Pro Tips
+
+- Support call without GVL in CRuby (use rb\_thread\_call\_without\_gvl())
+
+# Fork Me !
+
+This is experimental implementation.
+I'm waiting for your idea and Pull Request !
+
+# see also
+
+- man kqueue
+- http://people.freebsd.org/~jlemon/papers/kqueue_freenix.pdf
+- https://www.freebsd.org/cgi/man.cgi?query=kqueue
+- your /usr/include/sys/event.h

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/extensiontask'
+require 'rake/testtask'
+
+task :default => [:compile, :test]
+
+Rake::ExtensionTask.new('kqueue') do |ext|
+end
+Rake::TestTask.new {|t| t.libs << 'test'}

data/examples/kqueue_server.rb

@@ -0,0 +1,76 @@
+#! /usr/bin/env ruby
+
+require 'kqueue'
+require 'socket'
+
+class KqServer
+  include Kqueue::Event::Constants
+
+  def self.start(port)
+    kqs = new(port)
+    yield kqs
+    loop do
+      kqs.wait.each do |ev|
+        ev.udata && ev.udata[1].call(ev.udata[0])
+      end
+    end
+  end
+
+  def initialize(port)
+    @kq = Kqueue.new
+    @server = TCPServer.open(port)
+    set_event @server, EVFILT_READ do
+      socket = @server.accept
+      set_event socket, EVFILT_READ do |socket|
+        loop do
+          chunk = socket.recv(1024)
+          @on_data && @on_data.call(chunk)
+          break if chunk.length < 4 || chunk[-4..-1] == "\r\n\r\n"
+        end
+        set_event socket, EVFILT_WRITE do |socket|
+          @on_end && @on_end.call(socket)
+          del_event(socket, EVFILT_READ)
+          del_event(socket, EVFILT_WRITE)
+          socket.close
+        end
+      end
+    end
+  end
+
+  def set_event(io, filter, &block)
+    @kq.kevent([Kqueue::Event.new(io.fileno, filter, EV_ADD, 0, 0, [io, block])], 0)
+  end
+
+  def del_event(io, filter)
+    @kq.kevent([Kqueue::Event.new(io.fileno, filter, EV_DELETE, 0, 0, nil)], 0)
+  end
+
+  def wait
+    @kq.kevent(nil, 128, 5)
+  end
+
+  def on_data(&block)
+    @on_data = block
+  end
+
+  def on_end(&block)
+    @on_end = block
+  end
+end
+
+puts "run http://127.0.0.1:4000/"
+
+KqServer.start(4000) do |s|
+  s.on_data do |chunk|
+    print chunk
+  end
+  s.on_end do |socket|
+    socket.write [
+      "HTTP/1.0 200 OK\r\n",
+      "Content-Length: 11\r\n",
+      "Content-Type: text/html\r\n",
+      "\r\n",
+      "Hello World\r\n",
+    ].join("")
+  end
+end

data/ext/kqueue/core.c

@@ -0,0 +1,238 @@
+#include "ruby.h"
+#include "ruby/io.h"
+#include "ruby/thread.h"
+
+#if defined(HAVE_SYS_TYPES_H) && defined(HAVE_SYS_EVENT_H) && defined(HAVE_SYS_TIME_H)
+
+#include <fcntl.h>
+#include <alloca.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/time.h>
+
+VALUE cKqueue;
+VALUE mKqueue_Event_Constants;
+VALUE cKqueue_Event;
+ID id_udata_marks;
+
+#define IVAR_GET(self) rb_ivar_get((self), id_udata_marks)
+#define IVAR_SET(self, obj) rb_ivar_set((self), id_udata_marks, (obj))
+
+enum enumEvents {
+  IDENT,
+  FILTER,
+  FLAGS,
+  FFLAGS,
+  DATA,
+  UDATA
+};
+
+static VALUE
+rb_kqueue_initialize(VALUE self)
+{
+  rb_io_t *fp;
+  int fd;
+
+  fd = kqueue();
+  if (fd == -1)
+    rb_sys_fail("kqueue");
+  rb_update_max_fd(fd);
+
+  MakeOpenFile(self, fp);
+  fp->fd = fd;
+  fp->mode = FMODE_READABLE|FMODE_BINMODE;
+  rb_io_ascii8bit_binmode(self);
+
+  IVAR_SET(self, rb_hash_new());
+
+  return self;
+}
+
+struct kqueue_kevent_args {
+  int fd;
+  struct kevent *chl;
+  int ch_len;
+  struct kevent *evl;
+  int ev_len;
+  struct timespec *ts;
+};
+
+static void *
+rb_kqueue_kevent_func(void *ptr)
+{
+  const struct kqueue_kevent_args *args = ptr;
+  return (void*)(long)kevent(args->fd, args->chl, args->ch_len, args->evl, args->ev_len, args->ts);
+}
+
+static VALUE
+rb_kqueue_kevent(int argc, VALUE *argv, VALUE self)
+{
+  VALUE ch_list, max_events, timeout, ev, ready_evlist;
+  struct kqueue_kevent_args args;
+  struct timespec ts;
+  struct timespec *pts = NULL;
+  struct timeval tv;
+  int i;
+  int ev_len = 0, ch_len = 0;
+  int ready;
+  struct kevent *chl = NULL, *evl = NULL;
+  rb_io_t *fptr, *fptr_io;
+
+  fptr = RFILE(self)->fptr;
+  rb_io_check_initialized(fptr);
+
+  rb_scan_args(argc, argv, "21", &ch_list, &max_events, &timeout);
+  if (!NIL_P(max_events)) {
+    ev_len = FIX2INT(max_events);
+  }
+
+  if (!NIL_P(timeout)) {
+    tv = rb_time_timeval(timeout);
+    ts.tv_sec = (time_t)tv.tv_sec;
+    ts.tv_nsec = (long)tv.tv_usec * 1000;
+    pts = &ts;
+  }
+
+  if (!NIL_P(ch_list)) {
+    Check_Type(ch_list, T_ARRAY);
+    ch_len = RARRAY_LEN(ch_list);
+
+    chl = alloca(sizeof(struct kevent) * ch_len);
+    for (i = 0; i < ch_len; i++) {
+      ev = RARRAY_AREF(ch_list, i);
+      if (!rb_obj_is_kind_of(ev, cKqueue_Event)) {
+        rb_raise(rb_eTypeError, "must be set Array of Event object");
+      }
+
+      chl[i].ident = FIX2INT(RSTRUCT_GET(ev, IDENT));
+      chl[i].filter = FIX2INT(RSTRUCT_GET(ev, FILTER));
+      chl[i].flags = FIX2UINT(RSTRUCT_GET(ev, FLAGS));
+      chl[i].fflags = FIX2UINT(RSTRUCT_GET(ev, FFLAGS));
+      chl[i].data = NUM2LONG(RSTRUCT_GET(ev, DATA));
+      {
+        VALUE fileno = RSTRUCT_GET(ev, IDENT);
+        VALUE filter = RSTRUCT_GET(ev, FILTER);
+        VALUE udata = RSTRUCT_GET(ev, UDATA);
+        VALUE ivar = IVAR_GET(self);
+        VALUE h = rb_hash_aref(ivar, fileno);
+        if ((chl[i].flags & EV_DELETE) == EV_DELETE) {
+          if (chl[i].flags & ~EV_DELETE) {
+            rb_raise(rb_eArgError, "EV_DELETE cannot set with other");
+          }
+          if (NIL_P(h)) {
+            rb_raise(rb_eArgError, "delete udata not found");
+          }
+          rb_hash_delete(h, filter);
+          if (RHASH_EMPTY_P(h)) {
+            rb_hash_delete(ivar, fileno);
+          }
+          udata = (VALUE)0;
+        }
+        else {
+          if (NIL_P(h)) {
+            h = rb_hash_aset(ivar, fileno, rb_hash_new());
+          }
+          rb_hash_aset(h, filter, udata);
+        }
+        IVAR_SET(self, ivar);
+        chl[i].udata = (void*)udata;
+      }
+    }
+  }
+
+  if (0 < ev_len) {
+    evl = alloca(sizeof(struct kevent) * ev_len);
+  }
+  else if (ev_len < 0) {
+    rb_raise(rb_eArgError, "negative size");
+  }
+
+  args.fd = fptr->fd;
+  args.chl = chl;
+  args.ch_len = ch_len;
+  args.evl = evl;
+  args.ev_len = ev_len;
+  args.ts = pts;
+
+RETRY:
+  ready = (int)(long)rb_thread_call_without_gvl(rb_kqueue_kevent_func, &args, RUBY_UBF_IO, 0);
+  if (ready == -1) {
+    if (errno == EINTR)
+      goto RETRY;
+    else
+      rb_sys_fail("kevent");
+  }
+
+  ready_evlist = rb_ary_new_capa(ready);
+  for (i = 0; i < ready; i++) {
+    ev = rb_obj_alloc(cKqueue_Event);
+    RSTRUCT_SET(ev, IDENT, INT2FIX(evl[i].ident));
+    RSTRUCT_SET(ev, FILTER, INT2FIX(evl[i].filter));
+    RSTRUCT_SET(ev, FLAGS, INT2FIX(evl[i].flags));
+    RSTRUCT_SET(ev, FFLAGS, INT2FIX(evl[i].fflags));
+    RSTRUCT_SET(ev, FLAGS, INT2FIX(evl[i].flags));
+    RSTRUCT_SET(ev, DATA, INT2FIX(evl[i].data));
+    RSTRUCT_SET(ev, UDATA, (VALUE)evl[i].udata);
+    rb_ary_store(ready_evlist, i, ev);
+  }
+  return ready_evlist;
+}
+#endif
+
+void
+Init_kqueue()
+{
+#if defined(HAVE_SYS_TYPES_H) && defined(HAVE_SYS_EVENT_H) && defined(HAVE_SYS_TIME_H)
+
+  id_udata_marks = rb_intern("@udata_marks");
+
+  cKqueue = rb_define_class("Kqueue", rb_cIO);
+  rb_define_method(cKqueue, "initialize", rb_kqueue_initialize, 0);
+  rb_define_method(cKqueue, "kevent", rb_kqueue_kevent, -1);
+
+  cKqueue_Event = rb_struct_define_under(cKqueue, "Event", "ident", "filter", "flags", "fflags", "data", "udata", NULL);
+
+  mKqueue_Event_Constants = rb_define_module_under(cKqueue_Event, "Constants");
+
+  rb_include_module(cKqueue_Event, mKqueue_Event_Constants);
+
+  /* actions */
+  rb_define_const(mKqueue_Event_Constants, "EV_ADD", INT2FIX((u_short)EV_ADD));
+  rb_define_const(mKqueue_Event_Constants, "EV_ENABLE", INT2FIX((u_short)EV_ENABLE));
+  rb_define_const(mKqueue_Event_Constants, "EV_DISABLE", INT2FIX((u_short)EV_DISABLE));
+  rb_define_const(mKqueue_Event_Constants, "EV_DELETE", INT2FIX((u_short)EV_DELETE));
+  rb_define_const(mKqueue_Event_Constants, "EV_RECEIPT", INT2FIX((u_short)EV_RECEIPT));
+  /* flags */
+  rb_define_const(mKqueue_Event_Constants, "EV_ONESHOT", INT2FIX((u_short)EV_ONESHOT));
+  rb_define_const(mKqueue_Event_Constants, "EV_CLEAR", INT2FIX((u_short)EV_CLEAR));
+  /* returned values */
+  rb_define_const(mKqueue_Event_Constants, "EV_EOF", INT2FIX((u_short)EV_EOF));
+  rb_define_const(mKqueue_Event_Constants, "EV_ERROR", INT2FIX((u_short)EV_ERROR));
+
+  /* for filter */
+  rb_define_const(mKqueue_Event_Constants, "EVFILT_READ", INT2FIX((short)EVFILT_READ));
+  rb_define_const(mKqueue_Event_Constants, "EVFILT_WRITE", INT2FIX((short)EVFILT_WRITE));
+  rb_define_const(mKqueue_Event_Constants, "EVFILT_AIO", INT2FIX((short)EVFILT_AIO));
+  rb_define_const(mKqueue_Event_Constants, "EVFILT_VNODE", INT2FIX((short)EVFILT_VNODE));
+  rb_define_const(mKqueue_Event_Constants, "EVFILT_PROC", INT2FIX((short)EVFILT_PROC));
+  rb_define_const(mKqueue_Event_Constants, "EVFILT_SIGNAL", INT2FIX((short)EVFILT_SIGNAL));
+  rb_define_const(mKqueue_Event_Constants, "EVFILT_MACHPORT", INT2FIX((short)EVFILT_MACHPORT));
+
+  // for EVFILT_VNODE
+  rb_define_const(mKqueue_Event_Constants, "NOTE_DELETE", INT2FIX((u_int)NOTE_DELETE));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_WRITE", INT2FIX((u_int)NOTE_WRITE));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_EXTEND", INT2FIX((u_int)NOTE_EXTEND));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_ATTRIB", INT2FIX((u_int)NOTE_ATTRIB));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_LINK", INT2FIX((u_int)NOTE_LINK));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_RENAME", INT2FIX((u_int)NOTE_RENAME));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_REVOKE", INT2FIX((u_int)NOTE_REVOKE));
+
+  // for EVFILT_PROC
+  rb_define_const(mKqueue_Event_Constants, "NOTE_EXIT", INT2FIX((u_int)NOTE_EXIT));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_EXITSTATUS", INT2FIX((u_int)NOTE_EXITSTATUS));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_FORK", INT2FIX((u_int)NOTE_FORK));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_EXEC", INT2FIX((u_int)NOTE_EXEC));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_SIGNAL", INT2FIX((u_int)NOTE_SIGNAL));
+  rb_define_const(mKqueue_Event_Constants, "NOTE_REAP", INT2FIX((u_int)NOTE_REAP));
+#endif
+}

data/ext/kqueue/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+headers = %w(sys/types.h sys/event.h sys/time.h)
+
+unless headers.all?{|h| have_header(h)}
+  puts "*** complie error: gem 'kqueue' must be installed #{headers.to_s}. ***"
+  puts "*** you can require 'kqueue'. But, you can not use Kqueue APIs. ***"
+end
+
+create_makefile('kqueue')

data/kqueue.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |spec|
+  spec.name          = "kqueue"
+  spec.version       = "0.0.1"
+  spec.authors       = ["ksss"]
+  spec.email         = ["co000ri@gmail.com"]
+  spec.summary       = %q{A Ruby binding for kqueue(2)}
+  spec.description   = %q{A Ruby binding for kqueue(2)}
+  spec.homepage      = "https://github.com/ksss/kqueue"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/kqueue/extconf.rb"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'test-unit'
+end

data/test/test_kqueue.rb

@@ -0,0 +1,149 @@
+require 'test/unit'
+require 'timeout'
+require 'tempfile'
+require 'kqueue'
+
+class TestIOKqueue < Test::Unit::TestCase
+  include Kqueue::Event::Constants
+
+  def test_initalize
+    kq = Kqueue.new
+    assert_instance_of(Kqueue, kq)
+    assert_kind_of(IO, kq)
+    assert { true == kq.close_on_exec? }
+    kq.close
+
+    Kqueue.open do |kq|
+      assert_instance_of(Kqueue, kq)
+      assert_instance_of(Kqueue::Event, Kqueue::Event.new)
+    end
+  end
+
+  def test_kevent
+    Tempfile.open("test") do |f|
+      Kqueue.open do |kq|
+        kev_r = Kqueue::Event.new(f.fileno, EVFILT_READ, EV_ADD, 0, 0, nil)
+        kev_w = Kqueue::Event.new(f.fileno, EVFILT_WRITE, EV_ADD, 0, 0, nil)
+        assert { [] == kq.kevent([kev_r, kev_w], 0) }
+        assert { [] == kq.kevent(nil, 0) }
+        assert { [Kqueue::Event.new(f.fileno, EVFILT_WRITE, EV_ADD, 0, 1, nil)] == kq.kevent(nil, 2) }
+        assert { [Kqueue::Event.new(f.fileno, EVFILT_WRITE, EV_ADD, 0, 1, nil)] == kq.kevent(nil, 2) }
+        message = 'hello world'
+        f.write message
+        f.rewind
+
+        expect = [
+          Kqueue::Event.new(f.fileno, EVFILT_WRITE, EV_ADD, 0, 1, nil),
+          Kqueue::Event.new(f.fileno, EVFILT_READ, EV_ADD, 0, message.length, nil)
+        ]
+        assert { expect == kq.kevent(nil, 2) }
+        f.close
+        assert { [] == kq.kevent(nil, 2, 0) }
+        assert_raise(ArgumentError) { kq.kevent(nil, -1) }
+      end
+    end
+  end
+
+  def test_kevent_delete
+    IO.pipe do |r, w|
+      Kqueue.open do |kq|
+        kev_w = Kqueue::Event.new(w.fileno, EVFILT_WRITE, EV_ADD, 0, 0, nil)
+        kq.kevent([kev_w], 0)
+        assert { [Kqueue::Event.new(w.fileno, EVFILT_WRITE, EV_ADD, 0, EV_ERROR, nil)] == kq.kevent(nil, 2, 0) }
+
+        kev_del = Kqueue::Event.new(w.fileno, EVFILT_WRITE, EV_DELETE, 0, 0, nil)
+        kq.kevent([kev_del], 0)
+        GC.start
+        assert { [] == kq.kevent(nil, 2, 0) }
+
+        kev_del = Kqueue::Event.new(w.fileno, EVFILT_WRITE, EV_ADD|EV_DELETE, 0, 0, nil)
+        assert_raise(ArgumentError) { kq.kevent([kev_del], 0) }
+
+        kev_del = Kqueue::Event.new(w.fileno, EVFILT_READ, EV_DELETE, 0, 0, nil)
+        assert_raise(ArgumentError) { kq.kevent([kev_del], 0) }
+      end
+    end
+  end
+
+  def test_kevent_have_udata
+    IO.pipe do |r, w|
+      Kqueue.open do |kq|
+        obj = Object.new
+        object_id = obj.object_id
+        kev_w = Kqueue::Event.new(w.fileno, EVFILT_WRITE, EV_ADD, 0, 0, obj)
+        ret = kq.kevent([kev_w], 1)
+        GC.start
+        assert { object_id == ret.first.udata.object_id }
+      end
+    end
+
+    IO.pipe do |r, w|
+      Kqueue.open do |kq|
+        str = "in_string"
+        ary = [:in_array]
+        prc = Proc.new{ :in_proc }
+        kev_w = Kqueue::Event.new(w.fileno, EVFILT_WRITE, EV_ADD, 0, 0, [str, ary, prc])
+        ret = kq.kevent([kev_w], 1)
+        GC.start
+        assert { [Kqueue::Event.new(w.fileno, EVFILT_WRITE, EV_ADD, 0, EV_ERROR, [str, ary, prc])] == ret }
+        assert { "in_string" == ret.first.udata[0] }
+        assert { [:in_array] == ret.first.udata[1] }
+        assert { prc == ret.first.udata[2] }
+      end
+    end
+  end
+
+  def test_kevent_timeout
+    IO.pipe do |r, w|
+      Kqueue.open do |kq|
+        kev_r = Kqueue::Event.new(r.fileno, EVFILT_READ, EV_ADD, 0, 0, nil)
+        assert { [] == kq.kevent([kev_r], 1, 0) }
+        assert { [] == kq.kevent([kev_r], 1, 0.01) }
+        assert_raise(Timeout::Error) do
+          timeout(0.01) { kq.kevent(nil, 1, 0.02) }
+        end
+        assert_raise(Errno::EINVAL) do
+          kq.kevent(nil, 0, -1)
+        end
+      end
+    end
+  end
+
+  def test_kevent_with_thread
+    IO.pipe do |r, w|
+      Kqueue.open do |kq|
+        message = 'ok go'
+        kev_r = Kqueue::Event.new(r.fileno, EVFILT_READ, EV_ADD, 0, 0, nil)
+        w.write message
+        w.close
+        GC.start
+        t = Thread.new {
+          kq.kevent([kev_r], 1)
+        }
+        assert { [Kqueue::Event.new(r.fileno, EVFILT_READ, EV_ADD|EV_EOF, 0, message.length, nil)] == t.value }
+      end
+    end
+  end
+
+  def test_file
+    Tempfile.create("test") do |f|
+      Kqueue.open do |kq|
+        kevs = [
+          Kqueue::Event.new(f.fileno, EVFILT_WRITE, EV_ADD|EV_ENABLE|EV_CLEAR, 0, 0, [1]),
+          Kqueue::Event.new(f.fileno, EVFILT_READ, EV_ADD|EV_ENABLE|EV_CLEAR, 0, 0, [2]),
+          Kqueue::Event.new(f.fileno, EVFILT_WRITE, EV_ADD, 0, 0, [3]),
+          Kqueue::Event.new(f.fileno, EVFILT_READ, EV_ADD, 0, 0, [4]),
+        ]
+        kq.kevent(kevs, 0)
+
+        GC.start
+        assert { [[3]] == kq.kevent(nil, 4).map(&:udata) }
+
+        f.write 'ok'
+        f.rewind
+        GC.start
+        assert { [[4], [3]] == kq.kevent(nil, 4).map(&:udata) }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: kqueue
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ksss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby binding for kqueue(2)
+email:
+- co000ri@gmail.com
+executables: []
+extensions:
+- ext/kqueue/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/kqueue_server.rb
+- ext/kqueue/core.c
+- ext/kqueue/extconf.rb
+- kqueue.gemspec
+- test/test_kqueue.rb
+homepage: https://github.com/ksss/kqueue
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: A Ruby binding for kqueue(2)
+test_files:
+- test/test_kqueue.rb