nio4r 1.2.1 → 2.5.3

data/ext/nio4r/org/nio4r/Selector.java

@@ -0,0 +1,299 @@
+package org.nio4r;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import java.nio.channels.Channel;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.CancelledKeyException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyIO;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.io.OpenFile;
+
+import org.nio4r.Monitor;
+
+public class Selector extends RubyObject {
+    private java.nio.channels.Selector selector;
+    private HashMap<SelectableChannel,SelectionKey> cancelledKeys;
+    private volatile boolean wakeupFired;
+
+    public Selector(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject backends(ThreadContext context, IRubyObject self) {
+        return context.runtime.newArray(context.runtime.newSymbol("java"));
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context) {
+        initialize(context, context.runtime.newSymbol("java"));
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject backend) {
+        if(backend != context.runtime.newSymbol("java")) {
+            throw context.runtime.newArgumentError(":java is the only supported backend");
+        }
+
+        this.cancelledKeys = new HashMap<SelectableChannel,SelectionKey>();
+        this.wakeupFired = false;
+
+        try {
+            this.selector = java.nio.channels.Selector.open();
+        } catch(IOException ie) {
+            throw context.runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject backend(ThreadContext context) {
+        return context.runtime.newSymbol("java");
+    }
+
+    @JRubyMethod
+    public IRubyObject close(ThreadContext context) {
+        try {
+            this.selector.close();
+        } catch(IOException ie) {
+            throw context.runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        return context.nil;
+    }
+
+    @JRubyMethod(name = "closed?")
+    public IRubyObject isClosed(ThreadContext context) {
+        Ruby runtime = context.getRuntime();
+        return this.selector.isOpen() ? runtime.getFalse() : runtime.getTrue();
+    }
+
+    @JRubyMethod(name = "empty?")
+    public IRubyObject isEmpty(ThreadContext context) {
+        Ruby runtime = context.getRuntime();
+        return this.selector.keys().isEmpty() ? runtime.getTrue() : runtime.getFalse();
+    }
+
+    @JRubyMethod
+    public IRubyObject register(ThreadContext context, IRubyObject io, IRubyObject interests) {
+        Ruby runtime = context.getRuntime();
+        Channel rawChannel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!this.selector.isOpen()) {
+            throw context.getRuntime().newIOError("selector is closed");
+        }
+
+        if(!(rawChannel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("not a selectable IO object");
+        }
+
+        SelectableChannel channel = (SelectableChannel)rawChannel;
+
+        try {
+            channel.configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        int interestOps = Nio4r.symbolToInterestOps(runtime, channel, interests);
+        SelectionKey key;
+
+        key = this.cancelledKeys.remove(channel);
+
+        if(key != null) {
+            key.interestOps(interestOps);
+        } else {
+            try {
+                key = channel.register(this.selector, interestOps);
+            } catch(java.lang.IllegalArgumentException ia) {
+                throw runtime.newArgumentError("mode not supported for this object: " + interests);
+            } catch(java.nio.channels.ClosedChannelException cce) {
+                throw context.runtime.newIOError(cce.getLocalizedMessage());
+            }
+        }
+
+        RubyClass monitorClass = runtime.getModule("NIO").getClass("Monitor");
+        Monitor monitor = (Monitor)monitorClass.newInstance(context, io, interests, this, null);
+        monitor.setSelectionKey(key);
+
+        return monitor;
+    }
+
+    @JRubyMethod
+    public IRubyObject deregister(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.getRuntime();
+        OpenFile file = RubyIO.convertToIO(context, io).getOpenFileInitialized();
+        if (file.fd() == null)
+            return context.nil;
+        Channel rawChannel = file.channel();
+
+        if(!(rawChannel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("not a selectable IO object");
+        }
+
+        SelectableChannel channel = (SelectableChannel)rawChannel;
+        SelectionKey key = channel.keyFor(this.selector);
+
+        if(key == null)
+            return context.nil;
+
+        Monitor monitor = (Monitor)key.attachment();
+        monitor.close(context, runtime.getFalse());
+        cancelledKeys.put(channel, key);
+
+        return monitor;
+    }
+
+    @JRubyMethod(name = "registered?")
+    public IRubyObject isRegistered(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.getRuntime();
+        Channel rawChannel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!(rawChannel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("not a selectable IO object");
+        }
+
+        SelectableChannel channel = (SelectableChannel)rawChannel;
+        SelectionKey key = channel.keyFor(this.selector);
+
+        if(key == null)
+            return context.nil;
+
+
+        if(((Monitor)key.attachment()).isClosed(context) == runtime.getTrue()) {
+            return runtime.getFalse();
+        } else {
+            return runtime.getTrue();
+        }
+    }
+
+    @JRubyMethod
+    public synchronized IRubyObject select(ThreadContext context, Block block) {
+        return select(context, context.nil, block);
+    }
+
+    @JRubyMethod
+    public synchronized IRubyObject select(ThreadContext context, IRubyObject timeout, Block block) {
+        Ruby runtime = context.getRuntime();
+
+        if(!this.selector.isOpen()) {
+            throw context.getRuntime().newIOError("selector is closed");
+        }
+
+        this.wakeupFired = false;
+        int ready = doSelect(runtime, context, timeout);
+
+        /* Timeout */
+        if(ready <= 0 && !this.wakeupFired) {
+            return context.nil;
+        }
+
+        RubyArray array = null;
+
+        if(!block.isGiven()) {
+            array = runtime.newArray(this.selector.selectedKeys().size());
+        }
+
+        Iterator selectedKeys = this.selector.selectedKeys().iterator();
+        while(selectedKeys.hasNext()) {
+            SelectionKey key = (SelectionKey)selectedKeys.next();
+            processKey(key);
+
+            selectedKeys.remove();
+
+            if(block.isGiven()) {
+                block.call(context, (IRubyObject)key.attachment());
+            } else {
+                array.add(key.attachment());
+            }
+        }
+
+        if(block.isGiven()) {
+            return RubyNumeric.int2fix(runtime, ready);
+        } else {
+            return array;
+        }
+    }
+
+    /* Run the selector */
+    private int doSelect(Ruby runtime, ThreadContext context, IRubyObject timeout) {
+        int result;
+
+        cancelKeys();
+        try {
+            context.getThread().beforeBlockingCall();
+            if(timeout.isNil()) {
+                result = this.selector.select();
+            } else {
+                double t = RubyNumeric.num2dbl(timeout);
+                if(t == 0) {
+                    result = this.selector.selectNow();
+                } else if(t < 0) {
+                    throw runtime.newArgumentError("time interval must be positive");
+                } else {
+                    long timeoutMilliSeconds = (long)(t * 1000);
+                    if(timeoutMilliSeconds == 0) {
+                      result = this.selector.selectNow();
+                    } else {
+                      result = this.selector.select(timeoutMilliSeconds);
+                    }
+                }
+            }
+            context.getThread().afterBlockingCall();
+            return result;
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+    }
+
+    /* Flush our internal buffer of cancelled keys */
+    private void cancelKeys() {
+        Iterator cancelledKeys = this.cancelledKeys.entrySet().iterator();
+        while(cancelledKeys.hasNext()) {
+            Map.Entry entry = (Map.Entry)cancelledKeys.next();
+            SelectionKey key = (SelectionKey)entry.getValue();
+            key.cancel();
+            cancelledKeys.remove();
+        }
+    }
+
+    // Remove connect interest from connected sockets
+    // See: http://stackoverflow.com/questions/204186/java-nio-select-returns-without-selected-keys-why
+    private void processKey(SelectionKey key) {
+        if(key.isValid() && (key.readyOps() & SelectionKey.OP_CONNECT) != 0) {
+            int interestOps = key.interestOps();
+
+            interestOps &= ~SelectionKey.OP_CONNECT;
+            interestOps |=  SelectionKey.OP_WRITE;
+
+            key.interestOps(interestOps);
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject wakeup(ThreadContext context) {
+        if(!this.selector.isOpen()) {
+            throw context.getRuntime().newIOError("selector is closed");
+        }
+
+        this.wakeupFired = true;
+        this.selector.wakeup();
+
+        return context.nil;
+    }
+}

data/ext/nio4r/selector.c

@@ -27,8 +27,12 @@ static void NIO_Selector_mark(struct NIO_Selector *loop);
 static void NIO_Selector_shutdown(struct NIO_Selector *selector);
 static void NIO_Selector_free(struct NIO_Selector *loop);
 
-/* Methods */
-static VALUE NIO_Selector_initialize(VALUE self);
+/* Class methods */
+static VALUE NIO_Selector_supported_backends(VALUE klass);
+
+/* Instance methods */
+static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE NIO_Selector_backend(VALUE self);
 static VALUE NIO_Selector_register(VALUE self, VALUE selectable, VALUE interest);
 static VALUE NIO_Selector_deregister(VALUE self, VALUE io);
 static VALUE NIO_Selector_is_registered(VALUE self, VALUE io);
@@ -64,7 +68,9 @@ void Init_NIO_Selector()
     cNIO_Selector = rb_define_class_under(mNIO, "Selector", rb_cObject);
     rb_define_alloc_func(cNIO_Selector, NIO_Selector_allocate);
 
-    rb_define_method(cNIO_Selector, "initialize", NIO_Selector_initialize, 0);
+    rb_define_singleton_method(cNIO_Selector, "backends", NIO_Selector_supported_backends, 0);
+    rb_define_method(cNIO_Selector, "initialize", NIO_Selector_initialize, -1);
+    rb_define_method(cNIO_Selector, "backend", NIO_Selector_backend, 0);
     rb_define_method(cNIO_Selector, "register", NIO_Selector_register, 2);
     rb_define_method(cNIO_Selector, "deregister", NIO_Selector_deregister, 1);
     rb_define_method(cNIO_Selector, "registered?", NIO_Selector_is_registered, 1);
@@ -93,12 +99,17 @@ static VALUE NIO_Selector_allocate(VALUE klass)
         rb_sys_fail("pipe");
     }
 
-    if(fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0) {
+    /* Use non-blocking reads/writes during wakeup, in case the buffer is full */
+    if(fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0 ||
+       fcntl(fds[1], F_SETFL, O_NONBLOCK) < 0) {
         rb_sys_fail("fcntl");
     }
 
     selector = (struct NIO_Selector *)xmalloc(sizeof(struct NIO_Selector));
-    selector->ev_loop = ev_loop_new(0);
+
+    /* Defer initializing the loop to #initialize */
+    selector->ev_loop = 0;
+
     ev_init(&selector->timer, NIO_Selector_timeout_callback);
 
     selector->wakeup_reader = fds[0];
@@ -106,9 +117,8 @@ static VALUE NIO_Selector_allocate(VALUE klass)
 
     ev_io_init(&selector->wakeup, NIO_Selector_wakeup_callback, selector->wakeup_reader, EV_READ);
     selector->wakeup.data = (void *)selector;
-    ev_io_start(selector->ev_loop, &selector->wakeup);
 
-    selector->closed = selector->selecting = selector->ready_count = 0;
+    selector->closed = selector->selecting = selector->wakeup_fired = selector->ready_count = 0;
     selector->ready_array = Qnil;
 
     return Data_Wrap_Struct(klass, NIO_Selector_mark, NIO_Selector_free, selector);
@@ -137,6 +147,7 @@ static void NIO_Selector_shutdown(struct NIO_Selector *selector)
         ev_loop_destroy(selector->ev_loop);
         selector->ev_loop = 0;
     }
+
     selector->closed = 1;
 }
 
@@ -147,12 +158,83 @@ static void NIO_Selector_free(struct NIO_Selector *selector)
     xfree(selector);
 }
 
+/* Return an array of symbols for supported backends */
+static VALUE NIO_Selector_supported_backends(VALUE klass) {
+    unsigned int backends = ev_supported_backends();
+    VALUE result = rb_ary_new();
+
+    if(backends & EVBACKEND_EPOLL) {
+        rb_ary_push(result, ID2SYM(rb_intern("epoll")));
+    }
+
+    if(backends & EVBACKEND_POLL) {
+        rb_ary_push(result, ID2SYM(rb_intern("poll")));
+    }
+
+    if(backends & EVBACKEND_KQUEUE) {
+        rb_ary_push(result, ID2SYM(rb_intern("kqueue")));
+    }
+
+    if(backends & EVBACKEND_SELECT) {
+        rb_ary_push(result, ID2SYM(rb_intern("select")));
+    }
+
+    if(backends & EVBACKEND_PORT) {
+        rb_ary_push(result, ID2SYM(rb_intern("port")));
+    }
+
+    return result;
+}
+
 /* Create a new selector. This is more or less the pure Ruby version
    translated into an MRI cext */
-static VALUE NIO_Selector_initialize(VALUE self)
+static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
 {
+    ID backend_id;
+    VALUE backend;
     VALUE lock;
 
+    struct NIO_Selector *selector;
+    unsigned int flags = 0;
+
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    rb_scan_args(argc, argv, "01", &backend);
+
+    if(backend != Qnil) {
+        if(!rb_ary_includes(NIO_Selector_supported_backends(CLASS_OF(self)), backend)) {
+            rb_raise(rb_eArgError, "unsupported backend: %s",
+                RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
+        }
+
+        backend_id = SYM2ID(backend);
+
+        if(backend_id == rb_intern("epoll")) {
+            flags = EVBACKEND_EPOLL;
+        } else if(backend_id == rb_intern("poll")) {
+            flags = EVBACKEND_POLL;
+        } else if(backend_id == rb_intern("kqueue")) {
+            flags = EVBACKEND_KQUEUE;
+        } else if(backend_id == rb_intern("select")) {
+            flags = EVBACKEND_SELECT;
+        } else if(backend_id == rb_intern("port")) {
+            flags = EVBACKEND_PORT;
+        } else {
+            rb_raise(rb_eArgError, "unsupported backend: %s",
+                RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
+        }
+    }
+
+    /* Ensure the selector loop has not yet been initialized */
+    assert(!selector->ev_loop);
+
+    selector->ev_loop = ev_loop_new(flags);
+    if(!selector->ev_loop) {
+        rb_raise(rb_eIOError, "error initializing event loop");
+    }
+
+    ev_io_start(selector->ev_loop, &selector->wakeup);
+
     rb_ivar_set(self, rb_intern("selectables"), rb_hash_new());
     rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
 
@@ -163,6 +245,30 @@ static VALUE NIO_Selector_initialize(VALUE self)
     return Qnil;
 }
 
+static VALUE NIO_Selector_backend(VALUE self) {
+    struct NIO_Selector *selector;
+
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+    if(selector->closed) {
+        rb_raise(rb_eIOError, "selector is closed");
+    }
+
+    switch (ev_backend(selector->ev_loop)) {
+        case EVBACKEND_EPOLL:
+            return ID2SYM(rb_intern("epoll"));
+        case EVBACKEND_POLL:
+            return ID2SYM(rb_intern("poll"));
+        case EVBACKEND_KQUEUE:
+            return ID2SYM(rb_intern("kqueue"));
+        case EVBACKEND_SELECT:
+            return ID2SYM(rb_intern("select"));
+        case EVBACKEND_PORT:
+            return ID2SYM(rb_intern("port"));
+    }
+
+    return ID2SYM(rb_intern("unknown"));
+}
+
 /* Synchronize around a reentrant selector lock */
 static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args)
 {
@@ -173,7 +279,7 @@ static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VA
 
     if(lock_holder != current_thread) {
         lock = rb_ivar_get(self, rb_intern("lock"));
-        rb_funcall(lock, rb_intern("lock"), 0, 0);
+        rb_funcall(lock, rb_intern("lock"), 0);
         rb_ivar_set(self, rb_intern("lock_holder"), current_thread);
 
         /* We've acquired the lock, so ensure we unlock it */
@@ -192,7 +298,7 @@ static VALUE NIO_Selector_unlock(VALUE self)
     rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
 
     lock = rb_ivar_get(self, rb_intern("lock"));
-    rb_funcall(lock, rb_intern("unlock"), 0, 0);
+    rb_funcall(lock, rb_intern("unlock"), 0);
 
     return Qnil;
 }
@@ -307,82 +413,61 @@ static VALUE NIO_Selector_select_synchronized(VALUE *args)
     }
 
     ready = NIO_Selector_run(selector, args[1]);
-    if(ready > 0) {
-        if(rb_block_given_p()) {
-            return INT2NUM(ready);
-        } else {
-            ready_array = selector->ready_array;
+
+    /* Timeout */
+    if(ready < 0) {
+        if(!rb_block_given_p()) {
             selector->ready_array = Qnil;
-            return ready_array;
         }
+
+        return Qnil;
+    }
+
+    if(rb_block_given_p()) {
+        return INT2NUM(ready);
     } else {
+        ready_array = selector->ready_array;
         selector->ready_array = Qnil;
-        return Qnil;
+        return ready_array;
     }
 }
 
 static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
 {
+    int ev_run_flags = EVRUN_ONCE;
     int result;
+    double timeout_val;
+
     selector->selecting = 1;
+    selector->wakeup_fired = 0;
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) || defined(HAVE_RB_THREAD_ALONE)
-    /* Implement the optional timeout (if any) as a ev_timer */
-    if(timeout != Qnil) {
-        /* It seems libev is not a fan of timers being zero, so fudge a little */
-        selector->timer.repeat = NUM2DBL(timeout) + 0.0001;
-        ev_timer_again(selector->ev_loop, &selector->timer);
-    } else {
+    if(timeout == Qnil) {
+        /* Don't fire a wakeup timeout if we weren't passed one */
         ev_timer_stop(selector->ev_loop, &selector->timer);
-    }
-#else
-    /* Store when we started the loop so we can calculate the timeout */
-    ev_tstamp started_at = ev_now(selector->ev_loop);
-#endif
-
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-    /* libev is patched to release the GIL when it makes its system call */
-    ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
-#elif defined(HAVE_RB_THREAD_ALONE)
-    /* If we're the only thread we can make a blocking system call */
-    if(rb_thread_alone()) {
-#else
-    /* If we don't have rb_thread_alone() we can't block */
-    if(0) {
-#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
-
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION) && !defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-        TRAP_BEG;
-        ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
-        TRAP_END;
     } else {
-        /* We need to busy wait as not to stall the green thread scheduler
-           Ruby 1.8: just say no! :( */
-        ev_timer_init(&selector->timer, NIO_Selector_timeout_callback, BUSYWAIT_INTERVAL, BUSYWAIT_INTERVAL);
-        ev_timer_start(selector->ev_loop, &selector->timer);
-
-        /* Loop until we receive events */
-        while(selector->selecting && !selector->ready_count) {
-            TRAP_BEG;
-            ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
-            TRAP_END;
-
-            /* Run the next green thread */
-            rb_thread_schedule();
-
-            /* Break if the timeout has elapsed */
-            if(timeout != Qnil && ev_now(selector->ev_loop) - started_at >= NUM2DBL(timeout))
-                break;
+        timeout_val = NUM2DBL(timeout);
+        if(timeout_val == 0) {
+            /* If we've been given an explicit timeout of 0, perform a non-blocking
+               select operation */
+            ev_run_flags = EVRUN_NOWAIT;
+        } else {
+            selector->timer.repeat = timeout_val;
+            ev_timer_again(selector->ev_loop, &selector->timer);
         }
-
-        ev_timer_stop(selector->ev_loop, &selector->timer);
     }
-#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
+
+    /* libev is patched to release the GIL when it makes its system call */
+    ev_run(selector->ev_loop, ev_run_flags);
 
     result = selector->ready_count;
     selector->selecting = selector->ready_count = 0;
 
-    return result;
+    if(result > 0 || selector->wakeup_fired) {
+        selector->wakeup_fired = 0;
+        return result;
+    } else {
+        return -1;
+    }
 }
 
 /* Wake the selector up from another thread */
@@ -395,7 +480,9 @@ static VALUE NIO_Selector_wakeup(VALUE self)
         rb_raise(rb_eIOError, "selector is closed");
     }
 
+    selector->wakeup_fired = 1;
     write(selector->wakeup_writer, "\0", 1);
+
     return Qnil;
 }
 
@@ -445,8 +532,6 @@ static VALUE NIO_Selector_is_empty(VALUE self)
 /* Called whenever a timeout fires on the event loop */
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
 {
-    /* We don't actually need to do anything here, the mere firing of the
-       timer is sufficient to interrupt the selector. However, libev still wants a callback */
 }
 
 /* Called whenever a wakeup request is sent to a selector */
@@ -467,6 +552,8 @@ void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, in
     struct NIO_Selector *selector = monitor_data->selector;
     VALUE monitor = monitor_data->self;
 
+    assert(monitor_data->interests != 0);
+
     assert(selector != 0);
     selector->ready_count++;
     monitor_data->revents = revents;