nio4r 1.2.1-java → 2.0.0-java

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

@@ -0,0 +1,278 @@
+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 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.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
+    public IRubyObject initialize(ThreadContext context) {
+        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();
+        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;
+
+        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.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

@@ -29,6 +29,7 @@ static void NIO_Selector_free(struct NIO_Selector *loop);
 
 /* Methods */
 static VALUE NIO_Selector_initialize(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);
@@ -65,6 +66,7 @@ void Init_NIO_Selector()
     rb_define_alloc_func(cNIO_Selector, NIO_Selector_allocate);
 
     rb_define_method(cNIO_Selector, "initialize", NIO_Selector_initialize, 0);
+    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 +95,15 @@ 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);
+
     ev_init(&selector->timer, NIO_Selector_timeout_callback);
 
     selector->wakeup_reader = fds[0];
@@ -106,9 +111,10 @@ 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 +143,7 @@ static void NIO_Selector_shutdown(struct NIO_Selector *selector)
         ev_loop_destroy(selector->ev_loop);
         selector->ev_loop = 0;
     }
+
     selector->closed = 1;
 }
 
@@ -163,6 +170,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)
 {
@@ -307,26 +338,32 @@ 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 result;
+
     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 */
@@ -335,54 +372,19 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     } else {
         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;
-        }
-
-        ev_timer_stop(selector->ev_loop, &selector->timer);
-    }
-#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
 
     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 +397,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 +449,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 */