epoll 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af3e6c1172e4e5d592bc3684a61f2dd25ba9613b
+  data.tar.gz: bffa9bab1512afd08c4deb1367e3b0fc87e1fe98
+SHA512:
+  metadata.gz: 9f8249e738f8e48e519a086a1508c64ec6cbd0d03e27893480836410e4e4af3d18449ccd7b2ea4689686b606e11aab152b633eb548906134bfbdc2164a462ef7
+  data.tar.gz: 189aa3dcf3f0ea548ed3eb0111d8fe16b417c76ed5f21daf56a7788a9f3dceca9384340d0bde472b16e0276363749e2308c92b84a9ea07c0015944bb43710a70

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.4
+  - 2.2.0
+os:
+  - linux

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    epoll (0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    power_assert (0.1.3)
+    rake (10.3.2)
+    rake-compiler (0.8.3)
+      rake
+    test-unit (3.0.1)
+      power_assert
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  epoll!
+  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,119 @@
+epoll
+===
+
+[![Build Status](https://travis-ci.org/ksss/epoll.svg?branch=master)](https://travis-ci.org/ksss/epoll)
+
+A binding of epoll(7) on Ruby.
+
+**epoll(7)** can use Linux only. (because must be installed sys/epoll.h)
+
+# Usage
+
+```ruby
+require 'epoll'
+
+# Epoll < IO
+
+# Epoll.create
+#   call epoll_create(2)
+#   it's just alias of `open`
+#   Epoll object stock a File Descriptor returned by epoll_create(2)
+#   return: instance of Epoll (kind of IO)
+epoll = Epoll.create
+
+# IO object add to interest list
+#   call epoll_ctl(2)
+epoll.add(io, Epoll::IN)  # same way to epoll.ctl(Epoll::CTL_ADD, io, Epoll::IN)
+
+# change waiting events
+#   call epoll_ctl(2)
+epoll.mod(io, Epoll::OUT) # same way to epoll.ctl(Epoll::CTL_MOD, io, Epoll::OUT)
+
+# remove from interest list
+#   call epoll_ctl(2)
+epoll.del(io)             # same way to epoll.ctl(Epoll::CTL_DEL, io)
+
+loop do
+  # Epoll#wait(timeout=-1)
+  #   call epoll_wait(2)
+  #   timeout = -1: block until receive event or signals
+  #   timeout = 0: return all io's can I/O on non block
+  #   timeout > 0: block when timeout pass miri second or receive events or signals
+  #   return: Array of Epoll::Event
+  evlist = epoll.wait
+
+  # ev is instance of Epoll::Event like `struct epoll_event`
+  # it's instance of `class Epoll::Event < Struct.new(:data, :events); end`
+  evlist.each do |ev|
+    # Epoll::Event#events is event flag bits (Fixnum)
+    if (ev.events & Epoll::IN) != 0
+      # Epoll::Event#data is notified IO (IO)
+      # e.g. it's expect to I/O readable
+      puts ev.data.read
+    elsif (ev.events & Epoll::HUP|Epoll::ERR) != 0
+      ev.data.close
+      break
+    end
+  end
+end
+
+# you can close File Descriptor for epoll when finish to use
+epoll.close #=> nil
+
+# and you can check closed
+epoll.closed? #=> true
+
+# and very useful way is that call `create` with block like `IO.open`
+# return: block result
+Epoll.create do |epoll|
+  # ensure automatic call `epoll.close` when out block
+end
+```
+
+## ctl options
+
+ctl options|description
+---|---
+**Epoll::CTL_ADD**|add to interest list for created epoll fd
+**Epoll::CTL_MOD**|change io events
+**Epoll::CTL_DEL**|delete in interest list
+
+## Event flags
+
+event flags|ctl|wait|description
+---|---|---|---
+**Epoll::IN**|o|o|readable
+**Epoll::PRI**|o|o|high priority read
+**Epoll::HUP**|o|o|peer socket was shutdown
+**Epoll::OUT**|o|o|writable
+**Epoll::ET**|o|x|use edge trigger
+**Epoll::ONESHOT**|o|x|auto watching stop when notified(but stay in list)
+**Epoll::ERR**|x|o|raise error
+**Epoll::HUP**|x|o|raise hang up
+
+see also **man epoll(7)**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'epoll'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install epoll
+
+# Pro Tips
+
+- Support call without GVL in CRuby (use rb\_thread\_call\_without\_gvl())
+- Close on exec flag set by default if you can use (use epoll_create1(EPOLL_CLOEXEC))
+- Epoll#wait max return array size is 256 on one time (of course, overflowing and then carried next)
+
+# Fork Me !
+
+This is experimental implementation.
+I'm waiting for your idea and Pull Request !

data/Rakefile

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

data/epoll.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |spec|
+  spec.name          = "epoll"
+  spec.version       = "0.3.0"
+  spec.authors       = ["ksss"]
+  spec.email         = ["co000ri@gmail.com"]
+  spec.summary       = %q{A Ruby binding for epoll(7)}
+  spec.description   = %q{A Ruby binding for epoll(7)}
+  spec.homepage      = "https://github.com/ksss/epoll"
+  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/epoll/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/examples/epoll_server.rb

@@ -0,0 +1,46 @@
+#! /usr/bin/env ruby
+
+require 'epoll'
+require 'socket'
+
+server = TCPServer.open(4000)
+puts "run http://127.0.0.1:4000/"
+
+response = [
+  "HTTP/1.0 200 OK\r\n",
+  "Content-Length: 5\r\n",
+  "Content-Type: text/html\r\n",
+  "\r\n",
+  "HELLO\r\n",
+].join("")
+
+ep = Epoll.create
+ep.add server, Epoll::IN
+
+Signal.trap(:INT) {
+  ep.close
+  server.close
+}
+
+loop do
+  ep.wait.each do |ev|
+    data = ev.data
+    events = ev.events
+
+    if data == server
+      socket = server.accept
+      ep.add socket, Epoll::IN|Epoll::ET
+    elsif (events & Epoll::IN) != 0
+      data.recv(1024)
+      ep.mod data, Epoll::OUT|Epoll::ET
+    elsif (events & Epoll::OUT) != 0
+      data.puts response
+      ep.del data
+      data.close
+    elsif (events & (Epoll::HUP|Epoll::ERR)) != 0
+      p "Epoll::HUP|Epoll::ERR"
+    else
+      raise IOError
+    end
+  end
+end

data/ext/epoll/core.c

@@ -0,0 +1,194 @@
+#include "ruby.h"
+#include "ruby/io.h"
+#include "ruby/thread.h"
+
+#ifdef HAVE_SYS_EPOLL_H
+
+#include <sys/epoll.h>
+#include <fcntl.h>
+
+#define EPOLL_WAIT_MAX_EVENTS 256
+
+VALUE cEpoll;
+VALUE cEpoll_Constants;
+VALUE cEpoll_Event;
+
+static VALUE
+rb_epoll_initialize(VALUE self)
+{
+  rb_io_t *fp;
+  int fd;
+
+#if defined(HAVE_EPOLL_CREATE1) && defined(EPOLL_CLOEXEC)
+  fd = epoll_create1(EPOLL_CLOEXEC);
+  if (fd == -1)
+    rb_sys_fail("epoll_create1(2) was failed");
+#else
+  fd = epoll_create(1024);
+  if (fd == -1)
+    rb_sys_fail("epoll_create(2) was failed");
+#endif
+  rb_update_max_fd(fd);
+
+  MakeOpenFile(self, fp);
+  fp->fd = fd;
+  fp->mode = FMODE_READABLE|FMODE_BINMODE;
+  rb_io_ascii8bit_binmode(self);
+
+  /**
+  * It's also using GC mark.
+  * So, I don't know other way how to GC guard io objects.
+  */
+  rb_ivar_set(self, rb_intern("@evlist"), rb_ary_new());
+  return self;
+}
+
+static VALUE
+rb_epoll_ctl(int argc, VALUE *argv, VALUE self)
+{
+  struct epoll_event ev;
+  VALUE flag;
+  VALUE io;
+  VALUE events;
+  VALUE evlist;
+  rb_io_t *fptr;
+  rb_io_t *fptr_io;
+  int fd;
+
+  fptr = RFILE(self)->fptr;
+  rb_io_check_initialized(fptr);
+
+  switch (rb_scan_args(argc, argv, "21", &flag, &io, &events)) {
+    case 2:
+      if (FIX2INT(flag) != EPOLL_CTL_DEL)
+        rb_raise(rb_eArgError, "too few argument for CTL_ADD or CTL_MOD");
+    break;
+    case 3:
+      if (FIX2INT(flag) == EPOLL_CTL_DEL)
+        rb_raise(rb_eArgError, "too many argument for CTL_DEL");
+
+      if ((FIX2LONG(events) & (EPOLLIN|EPOLLPRI|EPOLLRDHUP|EPOLLOUT|EPOLLET|EPOLLONESHOT)) == 0)
+        rb_raise(rb_eIOError, "undefined events");
+
+      ev.events = FIX2LONG(events);
+      ev.data.ptr = (void*)io;
+    break;
+  }
+
+  GetOpenFile(rb_io_get_io(io), fptr_io);
+  fd = fptr_io->fd;
+
+  if (epoll_ctl(fptr->fd, FIX2INT(flag), fd, &ev) == -1) {
+    char buf[128];
+    sprintf(buf, "epoll_ctl(2) was failed(epoll fd:%d, io fd:%d)", fptr->fd, fd);
+    rb_sys_fail(buf);
+  }
+
+  switch (FIX2INT(flag)) {
+    case EPOLL_CTL_ADD:
+      evlist = rb_ivar_get(self, rb_intern("@evlist"));
+      rb_ary_push(evlist, io);
+      rb_ivar_set(self, rb_intern("@evlist"), evlist);
+    break;
+    case EPOLL_CTL_DEL:
+      evlist = rb_ivar_get(self, rb_intern("@evlist"));
+      rb_ary_delete(evlist, io);
+      rb_ivar_set(self, rb_intern("@evlist"), evlist);
+    break;
+  }
+
+  return self;
+}
+
+struct epoll_wait_args {
+  int fd;
+  int ev_len;
+  struct epoll_event *evlist;
+  int timeout;
+};
+
+static void *
+rb_epoll_wait_func(void *ptr)
+{
+  const struct epoll_wait_args *data = ptr;
+  return (void*)(long)epoll_wait(data->fd, data->evlist, data->ev_len, data->timeout);
+}
+
+static VALUE
+rb_epoll_wait(int argc, VALUE *argv, VALUE self)
+{
+  struct epoll_event evlist[EPOLL_WAIT_MAX_EVENTS];
+  struct epoll_wait_args data;
+  int i, ready, timeout, ev_len;
+  VALUE ready_evlist;
+  VALUE event;
+  rb_io_t *fptr;
+  GetOpenFile(self, fptr);
+
+  switch (argc) {
+    case 0:
+      timeout = -1;
+    break;
+    case 1:
+      timeout = FIX2INT(argv[0]);
+    break;
+    default:
+      rb_raise(rb_eArgError, "too many argument");
+    break;
+  }
+
+  ev_len = RARRAY_LEN(rb_ivar_get(self, rb_intern("@evlist")));
+  if (ev_len <= 0)
+    rb_raise(rb_eIOError, "empty interest list");
+
+  data.fd = fptr->fd;
+  data.ev_len = ev_len < EPOLL_WAIT_MAX_EVENTS ? ev_len : EPOLL_WAIT_MAX_EVENTS;
+  data.evlist = evlist;
+  data.timeout = timeout;
+
+RETRY:
+  ready = (int)(long)rb_thread_call_without_gvl(rb_epoll_wait_func, &data, RUBY_UBF_IO, 0);
+  if (ready == -1) {
+    if (errno == EINTR)
+      goto RETRY;
+    else
+      rb_sys_fail("epoll_wait(2) was failed");
+  }
+
+  ready_evlist = rb_ary_new_capa(ready);
+  for (i = 0; i < ready; i++) {
+    event = rb_obj_alloc(cEpoll_Event);
+    RSTRUCT_SET(event, 0, (VALUE) evlist[i].data.ptr);
+    RSTRUCT_SET(event, 1, LONG2FIX(evlist[i].events));
+    rb_ary_store(ready_evlist, i, event);
+  }
+  return ready_evlist;
+}
+
+#endif // HAVE_SYS_EPOLL_H
+
+void
+Init_core()
+{
+#ifdef HAVE_SYS_EPOLL_H
+  cEpoll = rb_define_class("Epoll", rb_cIO);
+  rb_define_method(cEpoll, "initialize", rb_epoll_initialize, 0);
+  rb_define_method(cEpoll, "ctl", rb_epoll_ctl, -1);
+  rb_define_method(cEpoll, "wait", rb_epoll_wait, -1);
+
+  cEpoll_Constants = rb_define_module_under(cEpoll, "Constants");
+  rb_define_const(cEpoll_Constants, "IN", INT2FIX(EPOLLIN));
+  rb_define_const(cEpoll_Constants, "PRI", INT2FIX(EPOLLPRI));
+  rb_define_const(cEpoll_Constants, "RDHUP", INT2FIX(EPOLLRDHUP));
+  rb_define_const(cEpoll_Constants, "OUT", INT2FIX(EPOLLOUT));
+  rb_define_const(cEpoll_Constants, "ET", INT2FIX(EPOLLET));
+  rb_define_const(cEpoll_Constants, "ONESHOT", INT2FIX(EPOLLONESHOT));
+  rb_define_const(cEpoll_Constants, "ERR", INT2FIX(EPOLLERR));
+  rb_define_const(cEpoll_Constants, "HUP", INT2FIX(EPOLLHUP));
+  rb_define_const(cEpoll_Constants, "CTL_ADD", INT2FIX(EPOLL_CTL_ADD));
+  rb_define_const(cEpoll_Constants, "CTL_MOD", INT2FIX(EPOLL_CTL_MOD));
+  rb_define_const(cEpoll_Constants, "CTL_DEL", INT2FIX(EPOLL_CTL_DEL));
+
+  cEpoll_Event = rb_struct_define_under(cEpoll, "Event", "data", "events", NULL);
+#endif
+}

data/ext/epoll/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+if !have_header("sys/epoll.h")
+  puts "*** complie error: gem 'epoll' must be installed <sys/epoll.h>. ***"
+  puts "*** you can require 'io/epoll'. But, you can not use IO::Epoll APIs. ***"
+end
+have_func("epoll_create1", "sys/epoll.h")
+create_makefile('epoll/core')

data/lib/epoll.rb

@@ -0,0 +1,2 @@
+require 'epoll/core'
+require 'epoll/ext'

data/lib/epoll/ext.rb

@@ -0,0 +1,26 @@
+class Epoll
+  attr_accessor :evlist
+
+  include Epoll::Constants
+
+  class << self
+    alias create open
+  end
+
+  def size
+    @evlist.size
+  end
+  alias length size
+
+  def add(io, events)
+    ctl CTL_ADD, io, events
+  end
+
+  def mod(io, events)
+    ctl CTL_MOD, io, events
+  end
+
+  def del(io)
+    ctl CTL_DEL, io
+  end
+end

data/test/test_epoll.rb

@@ -0,0 +1,213 @@
+require 'test/unit'
+require 'timeout'
+require_relative '../lib/epoll'
+
+class TestIOEpoll < Test::Unit::TestCase
+  def test_initalize
+    assert_instance_of(Epoll, Epoll.new);
+    assert_instance_of(Epoll, Epoll.create);
+  end
+
+  def test_create_with_block
+    instance = nil
+    ret_val = Epoll.create do |ep|
+      instance = ep
+      assert { instance.closed? == false }
+      :block_end
+    end
+    assert { instance.kind_of?(Epoll) == true }
+    assert { instance.closed? == true }
+    assert { ret_val == :block_end }
+  end
+
+  def test_create_with_block_ensure_close
+    instance = nil
+    catch do |ok|
+      Epoll.create do |ep|
+        instance = ep
+        throw ok
+      end
+    end
+    assert { true == instance.closed? }
+
+    assert_nothing_raised do
+      Epoll.create do |ep|
+        ep.close
+      end
+    end
+  end
+
+  def test_inspect
+    Epoll.create do |ep|
+      fd = ep.fileno
+      assert { "#<Epoll:fd #{fd}>" == ep.inspect }
+      ep.close
+      assert { "#<Epoll:(closed)>" == ep.inspect }
+    end
+  end
+
+  def test_fileno
+    ep = Epoll.create
+    assert { 0 < ep.fileno }
+    ep.close
+    assert_raise(IOError) { ep.fileno }
+  end
+
+  def test_ctl
+    Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      assert { ep == ep.ctl(Epoll::CTL_ADD, io , Epoll::OUT) }
+      assert_raise(ArgumentError) { ep.ctl }
+      assert_raise(ArgumentError) { ep.ctl(Epoll::CTL_ADD) }
+      assert_raise(ArgumentError) { ep.ctl(Epoll::CTL_ADD, io) }
+      assert_raise(ArgumentError) { ep.ctl(-1, io) }
+      assert_raise(TypeError) { ep.ctl(nil, nil, nil) }
+    end
+  end
+
+  def test_add
+    ep = Epoll.create
+    io = IO.new(1, 'w')
+    assert_raise(IOError) { ep.add(io, 0) }
+    assert { ep == ep.add(io, Epoll::IN|Epoll::PRI|Epoll::RDHUP|Epoll::ET|Epoll::OUT) }
+    ep.close
+    assert_raise(Errno::EBADF) { ep.add(io, Epoll::OUT) }
+  end
+
+  def test_mod
+    ep = Epoll.create
+    io = IO.new(1, 'w')
+    assert_raise(Errno::ENOENT) { ep.mod(io, Epoll::IN) }
+    ep == ep.add(io, Epoll::OUT)
+    assert { ep == ep.mod(io, Epoll::IN) }
+    ep.close
+    assert_raise(Errno::EBADF) { ep.add(io, Epoll::OUT) }
+  end
+
+  def test_del
+    ep = Epoll.create
+    io = IO.new(1, 'w')
+    assert_raise(Errno::ENOENT) { ep.del(io) }
+    ep.add(io, Epoll::OUT)
+    assert { ep == ep.del(io) }
+    ep.close
+    assert_raise(Errno::EBADF) { ep.del(io) }
+  end
+
+  def test_wait
+    Epoll.create do |ep|
+      IO.pipe do |r, w|
+        ep.add(r, Epoll::IN)
+        ep.add(w, Epoll::OUT)
+        evlist = ep.wait
+        assert { [Epoll::Event.new(w, Epoll::OUT)] == evlist }
+
+        w.write('ok')
+        assert { 2 == ep.wait.length }
+
+        assert_raise(IOError) { Epoll.create.wait }
+      end
+    end
+  end
+
+  def test_wait_with_timeout
+    Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      ep.add(io, Epoll::IN)
+      assert { [] == ep.wait(0) }
+      assert { [] == ep.wait(1) }
+      assert_raise(TimeoutError) do
+        timeout(0.01) { ep.wait(-1) }
+      end
+      assert_raise(TypeError) { ep.wait(nil) }
+    end
+  end
+
+  def test_size
+    Epoll.create do |ep|
+      IO.pipe do |r, w|
+        ep.add(r, Epoll::IN)
+        assert { 1 == ep.size }
+        ep.add(w, Epoll::OUT)
+        assert { 2 == ep.size }
+        ep.del(w)
+        assert { 1 == ep.size }
+        ep.del(r)
+        assert { 0 == ep.size }
+      end
+    end
+  end
+
+  def test_close
+    assert_nothing_raised do
+      fileno = nil
+      10.times do
+        ep = Epoll.create
+        fileno = ep.fileno unless fileno
+        assert { fileno == ep.fileno }
+        ep.close
+
+        Epoll.create do
+        end
+      end
+    end
+
+    ep = Epoll.create
+    ep.close
+    assert_raise(IOError){ ep.close }
+  end
+
+  def test_closed?
+    ep = Epoll.create
+    assert { false == ep.closed? }
+    ep.close
+    assert { true == ep.closed? }
+  end
+
+  def test_dup
+    Epoll.create do |ep|
+      IO.pipe do |r, w|
+        ep.add(r, Epoll::IN)
+        ep.add(w, Epoll::OUT)
+        dup = ep.dup
+        assert { ep != dup }
+        assert { ep.fileno != dup.fileno }
+        assert { 2 == dup.size }
+        assert { 1 == dup.wait.length }
+        w.write 'ok'
+        assert { 2 == dup.wait.length }
+      end
+    end
+  end
+
+  def test_close_on_exec
+    if defined? Fcntl::FD_CLOEXEC
+      Epoll.create do |ep|
+        assert { true == ep.close_on_exec? }
+        ep.close_on_exec = false
+        assert { false == ep.close_on_exec? }
+        ep.close_on_exec = true
+        assert { true == ep.close_on_exec? }
+        ep.close_on_exec = false
+        assert { false == ep.close_on_exec? }
+        ep.close
+        assert_raise { ep.close_on_exec = true }
+        assert_raise { ep.close_on_exec? }
+      end
+    else
+      pend "Fcntl::FD_CLOEXEC undefined"
+    end
+  end
+
+  def test_thread
+    Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      ep.add(io, Epoll::OUT)
+      ret = nil
+      Thread.start {
+        ret = ep.wait
+      }.join
+      assert { io == ret[0].data }
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: epoll
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- ksss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-09 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 epoll(7)
+email:
+- co000ri@gmail.com
+executables: []
+extensions:
+- ext/epoll/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- epoll.gemspec
+- examples/epoll_server.rb
+- ext/epoll/core.c
+- ext/epoll/extconf.rb
+- lib/epoll.rb
+- lib/epoll/ext.rb
+- test/test_epoll.rb
+homepage: https://github.com/ksss/epoll
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A Ruby binding for epoll(7)
+test_files:
+- test/test_epoll.rb