io-epoll 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c4f6bb1879b7524f23926e37da7c5fe53dec55b4
+  data.tar.gz: a0b1c12561b78414aa9f9fb3b567be508daf2685
+SHA512:
+  metadata.gz: be6db2e498ced13bb8d5219f1d2ab60386cd00b8d3311887ad9dbf13feae7d902a59e8a096103cb16007a4c6944020ba58de827f46691e30316c7db9fa004c65
+  data.tar.gz: 736de758a7a0a143b51fca8831d5679bac11c66033e40c6d6cfcba14fc5cceefabe1a5a649007c13dfd5a66b884094090b3c4864931b1fe3aaae41ece987b946

data/.gitignore

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

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    io-epoll (0.0.1)
+
+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
+  io-epoll!
+  rake
+  rake-compiler
+  test-unit

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 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,74 @@
+io-epoll
+===
+
+An experimental binding of epoll(7).
+
+**epoll(7)** can use Linux only. (because must be installed sys/epoll.h)
+
+# Usage
+
+```ruby
+require 'io/epoll'
+
+IO.epoll([io1, io2, io3], Epoll::IN) do |ev|
+  # ev is IO::Epoll::Event object like `struct epoll_event`
+  # it's have data and events properties
+
+  # events is event flag bits (Fixnum)
+  events = ev.events
+
+  # data is notificated IO (IO)
+  data = ev.data
+end
+
+# on other way, you can make instance of IO::Epoll
+
+Epoll = IO::Epoll
+
+# IO::Epoll.create
+#   run epoll_create(2)
+#   it's just alias of `new`
+epoll = Epoll.create
+
+# IO::Epoll#ctl(option, io, flag)
+#   run epoll_ctl(2)
+#   option: you can choice epoll_ctl option in CTL_ADD, CTL_MOD and CTL_DEL.
+#     CTL_ADD: add io list to watching for created epoll fd
+#     CTL_MOD: you can change io events
+#     CTL_DEL: delete io in watching list
+#   io: set an IO object for watching.
+#   flag: set flag bits like Epoll::IN|Epoll::OUT|Epoll::ONESHOT etc...
+#     see also man epoll_ctl(2)
+epoll.ctl(Epoll::CTL_ADD, io, Epoll::IN)
+
+# and you can use short way
+epoll.add(io, Epoll::IN)  # same way to epoll.ctl(Epoll::CTL_ADD, io, Epoll::IN)
+epoll.mod(io, Epoll::OUT) # same way to epoll.ctl(Epoll::CTL_MOD, io, Epoll::IN)
+epoll.del(io)             # same way to epoll.ctl(Epoll::CTL_DEL, io)
+
+# IO::Epoll#wait(timeout=-1)
+#   run 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
+evlist = epoll.wait
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'io-epoll'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install io-epoll
+
+# 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'
+
+Rake::ExtensionTask.new('epoll') do |ext|
+  ext.name = 'epoll'
+  ext.ext_dir = 'ext/io/epoll'
+  ext.lib_dir = 'lib/io/epoll'
+end
+Rake::TestTask.new {|t| t.libs << 'test'}
+

data/ext/io/epoll/epoll.c

@@ -0,0 +1,231 @@
+#include "ruby.h"
+#include "ruby/io.h"
+#include "ruby/thread.h"
+#include <sys/epoll.h>
+
+VALUE cIO_Epoll;
+
+struct Epoll {
+  int epfd;
+  int ev_len;
+};
+
+static void
+rb_epoll_free(void *p)
+{
+  struct Epoll *ptr = p;
+  if (ptr) {
+    if (0 <= ptr->epfd) close(ptr->epfd);
+    ruby_xfree(ptr);
+  }
+}
+
+static size_t
+rb_epoll_memsize(const void *p)
+{
+  const struct Epoll *ptr = p;
+  if (!ptr) return 0;
+  return sizeof(struct Epoll);
+}
+
+static const rb_data_type_t epoll_data_type = {
+  "epoll",
+  {
+    NULL,
+    rb_epoll_free,
+    rb_epoll_memsize,
+  },
+  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
+};
+
+static struct Epoll*
+get_epoll(VALUE self)
+{
+  struct Epoll *ptr;
+  rb_check_frozen(self);
+  TypedData_Get_Struct(self, struct Epoll, &epoll_data_type, ptr);
+  if (!ptr) {
+    rb_raise(rb_eIOError, "uninitialized stream");
+  }
+  return ptr;
+}
+
+static VALUE
+rb_epoll_allocate(VALUE klass)
+{
+  struct Epoll *ptr;
+  return TypedData_Make_Struct(klass, struct Epoll, &epoll_data_type, ptr);
+}
+
+static VALUE
+rb_epoll_initialize(VALUE self)
+{
+  struct Epoll *ptr;
+  int epfd;
+
+  TypedData_Get_Struct(self, struct Epoll, &epoll_data_type, ptr);
+  if (ptr->epfd < 0) close(ptr->epfd);
+  epfd = epoll_create(1);
+  if (epfd == -1) {
+    rb_sys_fail("epoll_create was failed");
+  }
+  ptr->epfd = epfd;
+  ptr->ev_len = 0;
+  return self;
+}
+
+static VALUE
+rb_epoll_fileno(VALUE self)
+{
+  struct Epoll *ptr = get_epoll(self);
+  return INT2FIX(ptr->epfd);
+}
+
+static VALUE
+rb_epoll_ctl(int argc, VALUE *argv, VALUE self)
+{
+  struct Epoll *ptr = get_epoll(self);
+  struct epoll_event ev;
+  VALUE flag;
+  VALUE io;
+  VALUE events;
+  int fd;
+
+  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_ADD && FIX2INT(flag) != EPOLL_CTL_MOD) {
+      rb_raise(rb_eArgError, "too many argument for CTL_DEL");
+    }
+    ev.events = FIX2INT(events);
+    ev.data.ptr = (void*)io;
+    break;
+  }
+
+  fd = RFILE(io)->fptr->fd;
+
+  if (epoll_ctl(ptr->epfd, FIX2INT(flag), fd, &ev) == -1) {
+    char buf[128];
+    sprintf(buf, "epoll_ctl() was failed(epfd:%d, fd:%d)", ptr->epfd, fd);
+    rb_sys_fail(buf);
+  }
+
+  switch (FIX2INT(flag)) {
+  case EPOLL_CTL_ADD:
+    ptr->ev_len++;
+    break;
+  case EPOLL_CTL_DEL:
+    ptr->ev_len--;
+    break;
+  case EPOLL_CTL_MOD:
+    break;
+  default:
+    break;
+  }
+
+  return self;
+}
+
+struct epoll_wait_args {
+  struct Epoll *ptr;
+  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->ptr->epfd, data->evlist, data->ptr->ev_len, data->timeout);
+}
+
+static VALUE
+rb_epoll_wait(int argc, VALUE *argv, VALUE self)
+{
+  struct Epoll *ptr = get_epoll(self);
+  VALUE ready_evlist;
+  VALUE event;
+  struct epoll_event *evlist;
+  int i, ready;
+  int timeout = -1;
+  struct epoll_wait_args data;
+
+  if (argc == 1) {
+    timeout = FIX2INT(argv[0]);
+  }
+  evlist = ruby_xmalloc(ptr->ev_len * sizeof(struct epoll_event));
+
+  data.ptr = ptr;
+  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 {
+      ruby_xfree(evlist);
+      rb_sys_fail("epoll_wait() was failed");
+    }
+  }
+
+  ready_evlist = rb_ary_new_capa(ready);
+  for (i = 0; i < ready; i++) {
+    event = rb_obj_alloc(rb_path2class("IO::Epoll::Event"));
+    RSTRUCT_SET(event, 0, (VALUE) evlist[i].data.ptr);
+    RSTRUCT_SET(event, 1, INT2FIX(evlist[i].events));
+    rb_ary_store(ready_evlist, i, event);
+  }
+  ruby_xfree(evlist);
+  return ready_evlist;
+}
+
+static VALUE
+rb_epoll_close(VALUE self)
+{
+  struct Epoll *ptr = get_epoll(self);
+  if (close(ptr->epfd) == -1) {
+    rb_raise(rb_eIOError, "file descriptor duplicate close %ld", INT2FIX(ptr->epfd));
+  }
+  ptr->epfd = -1;
+  return Qnil;
+}
+
+static VALUE
+rb_epoll_length(VALUE self)
+{
+  struct Epoll *ptr = get_epoll(self);
+  return INT2FIX(ptr->ev_len);
+}
+
+void
+Init_epoll()
+{
+  cIO_Epoll = rb_define_class_under(rb_cIO, "Epoll", rb_cObject);
+  rb_define_alloc_func(cIO_Epoll, rb_epoll_allocate);
+
+  rb_define_method(cIO_Epoll, "initialize", rb_epoll_initialize, 0);
+  rb_define_method(cIO_Epoll, "fileno", rb_epoll_fileno, 0);
+  rb_define_method(cIO_Epoll, "ctl", rb_epoll_ctl, -1);
+  rb_define_method(cIO_Epoll, "wait", rb_epoll_wait, -1);
+  rb_define_method(cIO_Epoll, "close", rb_epoll_close, 0);
+  rb_define_method(cIO_Epoll, "length", rb_epoll_length, 0);
+  rb_define_alias(cIO_Epoll, "size", "length");
+  rb_define_const(cIO_Epoll, "IN", INT2FIX(EPOLLIN));
+  rb_define_const(cIO_Epoll, "PRI", INT2FIX(EPOLLPRI));
+  rb_define_const(cIO_Epoll, "RDHUP", INT2FIX(EPOLLRDHUP));
+  rb_define_const(cIO_Epoll, "OUT", INT2FIX(EPOLLOUT));
+  rb_define_const(cIO_Epoll, "ET", INT2FIX(EPOLLET));
+  rb_define_const(cIO_Epoll, "ONESHOT", INT2FIX(EPOLLONESHOT));
+  rb_define_const(cIO_Epoll, "ERR", INT2FIX(EPOLLERR));
+  rb_define_const(cIO_Epoll, "HUP", INT2FIX(EPOLLHUP));
+  rb_define_const(cIO_Epoll, "CTL_ADD", INT2FIX(EPOLL_CTL_ADD));
+  rb_define_const(cIO_Epoll, "CTL_MOD", INT2FIX(EPOLL_CTL_MOD));
+  rb_define_const(cIO_Epoll, "CTL_DEL", INT2FIX(EPOLL_CTL_DEL));
+}

data/ext/io/epoll/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+if !have_header("sys/epoll.h")
+  puts "*** err: <sys/epoll.h> header must be installed ***"
+  exit 1
+end
+create_makefile('io/epoll/epoll')

data/io-epoll.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |spec|
+  spec.name          = "io-epoll"
+  spec.version       = "0.0.1"
+  spec.authors       = ["ksss"]
+  spec.email         = ["co000ri@gmail.com"]
+  spec.summary       = %q{An experimental binding of epoll(7)}
+  spec.description   = %q{An experimental binding of epoll(7)}
+  spec.homepage      = ""
+  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/io/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/lib/io/epoll.rb

@@ -0,0 +1,51 @@
+require 'io/epoll/epoll'
+
+class IO
+  class Epoll
+    class Event < Struct.new(:data, :events)
+    end
+
+    class << self
+      alias create new
+    end
+
+    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
+
+    def closed?
+      fileno < 0
+    end
+  end
+
+  def self.epoll(ios, events)
+    open_len = ios.length
+    ep = Epoll.create
+    ios.each do |io|
+      ep.add(io, events)
+    end
+    if block_given?
+      while 0 < open_len
+        evlist = ep.wait
+        evlist.each do |ev|
+          yield ev
+          if ev.events & (Epoll::HUP|Epoll::ERR)
+            open_len -= 1
+            ev.data.close
+          end
+        end
+      end
+      nil
+    else
+      ep.wait
+    end
+  end
+end

data/test/test_epoll.rb

@@ -0,0 +1,126 @@
+require 'test/unit'
+require 'timeout'
+require_relative '../lib/io/epoll'
+
+class TestIOEpoll < Test::Unit::TestCase
+  def test_initalize
+    assert_instance_of(IO::Epoll, IO::Epoll.new);
+  end
+
+  def test_fileno
+    assert { 0 < IO::Epoll.new.fileno }
+  end
+
+  def test_ctl
+    ep = IO::Epoll.new
+    io = IO.new(1, 'w')
+    assert_raise(ArgumentError) { ep.ctl }
+    assert_raise(ArgumentError) { ep.ctl(IO::Epoll::CTL_ADD) }
+    assert_raise(ArgumentError) { ep.ctl(IO::Epoll::CTL_ADD, io) }
+    assert { ep == ep.ctl(IO::Epoll::CTL_ADD, io , IO::Epoll::OUT) }
+    assert_raise(ArgumentError) { ep.ctl(-1, io) }
+  end
+
+  def test_add
+    ep = IO::Epoll.new
+    io = IO.new(1, 'w')
+    assert { ep == ep.add(io, IO::Epoll::OUT) }
+    ep.close
+    assert_raise(Errno::EBADF) { ep.add(io, IO::Epoll::OUT) }
+  end
+
+  def test_mod
+    ep = IO::Epoll.new
+    io = IO.new(1, 'w')
+    assert_raise(Errno::ENOENT) { ep.mod(io, IO::Epoll::IN) }
+    ep == ep.add(io, IO::Epoll::OUT)
+    assert { ep == ep.mod(io, IO::Epoll::IN) }
+    ep.close
+    assert_raise(Errno::EBADF) { ep.add(io, IO::Epoll::OUT) }
+  end
+
+  def test_del
+    ep = IO::Epoll.new
+    io = IO.new(1, 'w')
+    assert_raise(Errno::ENOENT) { ep.del(io) }
+    ep.add(io, IO::Epoll::OUT)
+    assert { ep == ep.del(io) }
+    ep.close
+    assert_raise(Errno::EBADF) { ep.del(io) }
+  end
+
+  def test_wait
+    ep = IO::Epoll.new
+    io1 = IO.new(1, 'w')
+    io2 = IO.new(2, 'w')
+    ep.add(io1, IO::Epoll::OUT)
+    assert { [IO::Epoll::Event.new(io1, IO::Epoll::OUT)] == ep.wait }
+  end
+
+  def test_wait_with_timeout
+    ep = IO::Epoll.new
+    io = IO.new(1, 'w')
+    ep.add(io, IO::Epoll::IN)
+    assert { [] == ep.wait(0) }
+    assert { [] == ep.wait(1) }
+    assert_raise(TimeoutError) do
+      timeout(0.01) { ep.wait(-1) }
+    end
+  end
+
+  def test_size
+    ep = IO::Epoll.new
+    io = IO.new(0, 'r')
+    ep.add(io, IO::Epoll::IN)
+    assert { 1 == ep.size }
+    ep.del(io)
+    assert { 0 == ep.size }
+  end
+
+  def test_close_closed?
+    ep = IO::Epoll.new
+    assert { false == ep.closed? }
+    assert { nil == ep.close }
+    assert_raise(IOError){ ep.close }
+    assert { true == ep.closed? }
+  end
+
+  def test_epoll
+    r, w = IO.pipe
+    fork {
+      r.close
+      w.write('ok')
+    }
+    w.close
+    ret = []
+    evs = IO.epoll([r], IO::Epoll::IN)
+    assert { 'ok' == evs[0].data.read }
+    assert { false == evs[0].data.closed? }
+  end
+
+  def test_epoll_with_block
+    r, w = IO.pipe
+    fork {
+      r.close
+      w.write('ok')
+    }
+    w.close
+    ret = []
+    IO.epoll([r], IO::Epoll::IN) do |ev|
+      ret << ev
+      assert { 'ok' == ev.data.read }
+    end
+    assert { true == ret[0].data.closed? }
+  end
+
+  def test_thread
+    ep = IO::Epoll.new
+    io = IO.new(1, 'w')
+    ep.add(io, IO::Epoll::OUT)
+    ret = nil
+    Thread.start {
+      ret = ep.wait
+    }.join
+    assert { io == ret[0].data }
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: io-epoll
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ksss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-30 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: An experimental binding of epoll(7)
+email:
+- co000ri@gmail.com
+executables: []
+extensions:
+- ext/io/epoll/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/io/epoll/epoll.c
+- ext/io/epoll/extconf.rb
+- io-epoll.gemspec
+- lib/io/epoll.rb
+- test/test_epoll.rb
+homepage: ''
+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: An experimental binding of epoll(7)
+test_files:
+- test/test_epoll.rb