nio4r 0.2.2-java → 0.3.0-java

data/ext/libev/ev_select.c

@@ -1,7 +1,7 @@
 /*
  * libev select fd activity backend
  *
- * Copyright (c) 2007,2008,2009,2010 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -195,7 +195,12 @@ select_poll (EV_P_ ev_tstamp timeout)
        */
       if (errno == EINVAL)
         {
-          ev_sleep (timeout);
+          if (timeout)
+            {
+              unsigned long ms = timeout * 1e3;
+              Sleep (ms ? ms : 1);
+            }
+
           return;
         }
       #endif
@@ -269,9 +274,9 @@ select_poll (EV_P_ ev_tstamp timeout)
 int inline_size
 select_init (EV_P_ int flags)
 {
-  backend_fudge  = 0.; /* posix says this is zero */
-  backend_modify = select_modify;
-  backend_poll   = select_poll;
+  backend_mintime = 1e-6;
+  backend_modify  = select_modify;
+  backend_poll    = select_poll;
 
 #if EV_SELECT_USE_FD_SET
   vec_ri  = ev_malloc (sizeof (fd_set)); FD_ZERO ((fd_set *)vec_ri);
@@ -307,4 +312,3 @@ select_destroy (EV_P)
   #endif
 }
 
-

data/ext/libev/ev_vars.h

@@ -51,7 +51,7 @@ VARx(int, activecnt) /* total number of active events ("refcount") */
 VARx(EV_ATOMIC_T, loop_done)  /* signal by ev_break */
 
 VARx(int, backend_fd)
-VARx(ev_tstamp, backend_fudge) /* assumed typical timer resolution */
+VARx(ev_tstamp, backend_mintime) /* assumed typical timer resolution */
 VAR (backend_modify, void (*backend_modify)(EV_P_ int fd, int oev, int nev))
 VAR (backend_poll  , void (*backend_poll)(EV_P_ ev_tstamp timeout))
 
@@ -73,6 +73,8 @@ VARx(int, evfd)
 #endif
 VAR (evpipe, int evpipe [2])
 VARx(ev_io, pipe_w)
+VARx(EV_ATOMIC_T, pipe_write_wanted)
+VARx(EV_ATOMIC_T, pipe_write_skipped)
 
 #if !defined(_WIN32) || EV_GENWRAP
 VARx(pid_t, curpid)
@@ -180,7 +182,6 @@ VAR (fs_hash, ANFS fs_hash [EV_INOTIFY_HASHSIZE])
 #endif
 
 VARx(EV_ATOMIC_T, sig_pending)
-VARx(int, nosigmask)
 #if EV_USE_SIGNALFD || EV_GENWRAP
 VARx(int, sigfd)
 VARx(ev_io, sigfd_w)

data/ext/libev/ev_wrap.h

@@ -10,7 +10,7 @@
 #define activecnt ((loop)->activecnt)
 #define loop_done ((loop)->loop_done)
 #define backend_fd ((loop)->backend_fd)
-#define backend_fudge ((loop)->backend_fudge)
+#define backend_mintime ((loop)->backend_mintime)
 #define backend_modify ((loop)->backend_modify)
 #define backend_poll ((loop)->backend_poll)
 #define anfds ((loop)->anfds)
@@ -25,6 +25,8 @@
 #define evfd ((loop)->evfd)
 #define evpipe ((loop)->evpipe)
 #define pipe_w ((loop)->pipe_w)
+#define pipe_write_wanted ((loop)->pipe_write_wanted)
+#define pipe_write_skipped ((loop)->pipe_write_skipped)
 #define curpid ((loop)->curpid)
 #define postfork ((loop)->postfork)
 #define vec_ri ((loop)->vec_ri)
@@ -85,7 +87,6 @@
 #define fs_2625 ((loop)->fs_2625)
 #define fs_hash ((loop)->fs_hash)
 #define sig_pending ((loop)->sig_pending)
-#define nosigmask ((loop)->nosigmask)
 #define sigfd ((loop)->sigfd)
 #define sigfd_w ((loop)->sigfd_w)
 #define sigfd_set ((loop)->sigfd_set)
@@ -107,7 +108,7 @@
 #undef activecnt
 #undef loop_done
 #undef backend_fd
-#undef backend_fudge
+#undef backend_mintime
 #undef backend_modify
 #undef backend_poll
 #undef anfds
@@ -122,6 +123,8 @@
 #undef evfd
 #undef evpipe
 #undef pipe_w
+#undef pipe_write_wanted
+#undef pipe_write_skipped
 #undef curpid
 #undef postfork
 #undef vec_ri
@@ -182,7 +185,6 @@
 #undef fs_2625
 #undef fs_hash
 #undef sig_pending
-#undef nosigmask
 #undef sigfd
 #undef sigfd_w
 #undef sigfd_set

data/ext/nio4r/monitor.c

@@ -16,10 +16,11 @@ static void NIO_Monitor_free(struct NIO_Monitor *monitor);
 
 /* Methods */
 static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector, VALUE io, VALUE interests);
-static VALUE NIO_Monitor_close(VALUE self);
+static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self);
 static VALUE NIO_Monitor_is_closed(VALUE self);
 static VALUE NIO_Monitor_io(VALUE self);
 static VALUE NIO_Monitor_interests(VALUE self);
+static VALUE NIO_Monitor_selector(VALUE self);
 static VALUE NIO_Monitor_is_readable(VALUE self);
 static VALUE NIO_Monitor_is_writable(VALUE self);
 static VALUE NIO_Monitor_value(VALUE self);
@@ -43,10 +44,11 @@ void Init_NIO_Monitor()
     rb_define_alloc_func(cNIO_Monitor, NIO_Monitor_allocate);
 
     rb_define_method(cNIO_Monitor, "initialize", NIO_Monitor_initialize, 3);
-    rb_define_method(cNIO_Monitor, "close", NIO_Monitor_close, 0);
+    rb_define_method(cNIO_Monitor, "close", NIO_Monitor_close, -1);
     rb_define_method(cNIO_Monitor, "closed?", NIO_Monitor_is_closed, 0);
     rb_define_method(cNIO_Monitor, "io", NIO_Monitor_io, 0);
     rb_define_method(cNIO_Monitor, "interests", NIO_Monitor_interests, 0);
+    rb_define_method(cNIO_Monitor, "selector", NIO_Monitor_selector, 0);
     rb_define_method(cNIO_Monitor, "value", NIO_Monitor_value, 0);
     rb_define_method(cNIO_Monitor, "value=", NIO_Monitor_set_value, 1);
     rb_define_method(cNIO_Monitor, "readiness", NIO_Monitor_readiness, 0);
@@ -71,7 +73,7 @@ static void NIO_Monitor_free(struct NIO_Monitor *monitor)
     xfree(monitor);
 }
 
-static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector_obj, VALUE io, VALUE interests)
+static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE selector_obj)
 {
     struct NIO_Monitor *monitor;
     struct NIO_Selector *selector;
@@ -101,9 +103,9 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector_obj, VALUE io, VA
     GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
     ev_io_init(&monitor->ev_io, NIO_Monitor_callback, FPTR_TO_FD(fptr), monitor->interests);
 
-    rb_ivar_set(self, rb_intern("selector"), selector_obj);
     rb_ivar_set(self, rb_intern("io"), io);
     rb_ivar_set(self, rb_intern("interests"), interests);
+    rb_ivar_set(self, rb_intern("selector"), selector_obj);
 
     Data_Get_Struct(selector_obj, struct NIO_Selector, selector);
 
@@ -119,14 +121,24 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector_obj, VALUE io, VA
     return Qnil;
 }
 
-static VALUE NIO_Monitor_close(VALUE self)
+static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self)
 {
+    VALUE deregister, selector;
     struct NIO_Monitor *monitor;
     Data_Get_Struct(self, struct NIO_Monitor, monitor);
 
-    if(monitor->selector) {
+    rb_scan_args(argc, argv, "01", &deregister);
+    selector = rb_ivar_get(self, rb_intern("selector"));
+
+    if(selector != Qnil) {
         ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
         monitor->selector = 0;
+        rb_ivar_set(self, rb_intern("selector"), Qnil);
+
+        /* Default value is true */
+        if(deregister == Qtrue || deregister == Qnil) {
+            rb_funcall(selector, rb_intern("deregister"), 1, rb_ivar_get(self, rb_intern("io")));
+        }
     }
 
     return Qnil;
@@ -150,6 +162,11 @@ static VALUE NIO_Monitor_interests(VALUE self)
     return rb_ivar_get(self, rb_intern("interests"));
 }
 
+static VALUE NIO_Monitor_selector(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("selector"));
+}
+
 static VALUE NIO_Monitor_value(VALUE self)
 {
     return rb_ivar_get(self, rb_intern("value"));

data/ext/nio4r/org/nio4r/Nio4r.java

@@ -0,0 +1,409 @@
+package org.nio4r;
+
+import java.util.Iterator;
+import java.io.IOException;
+import java.nio.channels.Channel;
+import java.nio.channels.SocketChannel;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyIO;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyArray;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.load.Library;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.Block;
+
+public class Nio4r implements Library {
+    private Ruby ruby;
+
+    public void load(final Ruby ruby, boolean bln) {
+        this.ruby = ruby;
+
+        RubyModule nio = ruby.defineModule("NIO");
+
+        RubyClass selector = ruby.defineClassUnder("Selector", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass rc) {
+                return new Selector(ruby, rc);
+            }
+        }, nio);
+
+        selector.defineAnnotatedMethods(Selector.class);
+
+        RubyClass monitor = ruby.defineClassUnder("Monitor", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass rc) {
+                return new Monitor(ruby, rc);
+            }
+        }, nio);
+
+        monitor.defineAnnotatedMethods(Monitor.class);
+    }
+
+    public static int symbolToInterestOps(Ruby ruby, SelectableChannel channel, IRubyObject interest) {
+        if(interest == ruby.newSymbol("r")) {
+            if((channel.validOps() & SelectionKey.OP_ACCEPT) != 0) {
+              return SelectionKey.OP_ACCEPT;
+            } else {
+              return SelectionKey.OP_READ;
+            }
+        } else if(interest == ruby.newSymbol("w")) {
+            if(channel instanceof SocketChannel && !((SocketChannel)channel).isConnected()) {
+                return SelectionKey.OP_CONNECT;
+            } else {
+                return SelectionKey.OP_WRITE;
+            }
+        } else if(interest == ruby.newSymbol("rw")) {
+            int interestOps = 0;
+
+            /* nio4r emulates the POSIX behavior, which is sloppy about allowed modes */
+            if((channel.validOps() & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0) {
+                interestOps |= symbolToInterestOps(ruby, channel, ruby.newSymbol("r"));
+            }
+
+            if((channel.validOps() & (SelectionKey.OP_WRITE | SelectionKey.OP_CONNECT)) != 0) {
+                interestOps |= symbolToInterestOps(ruby, channel, ruby.newSymbol("w"));
+            }
+
+            return interestOps;
+        } else {
+            throw ruby.newArgumentError("invalid interest type: " + interest);
+        }
+    }
+
+    public static IRubyObject interestOpsToSymbol(Ruby ruby, int interestOps) {
+        switch(interestOps) {
+            case SelectionKey.OP_READ:
+            case SelectionKey.OP_ACCEPT:
+                return ruby.newSymbol("r");
+            case SelectionKey.OP_WRITE:
+            case SelectionKey.OP_CONNECT:
+                return ruby.newSymbol("w");
+            case SelectionKey.OP_READ | SelectionKey.OP_CONNECT:
+            case SelectionKey.OP_READ | SelectionKey.OP_WRITE:
+                return ruby.newSymbol("rw");
+            default:
+                throw ruby.newArgumentError("unknown interest op combination");
+        }
+    }
+
+    public class Selector extends RubyObject {
+        private java.nio.channels.Selector selector;
+
+        public Selector(final Ruby ruby, RubyClass rubyClass) {
+            super(ruby, rubyClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            try {
+                selector = java.nio.channels.Selector.open();
+            } catch(IOException ie) {
+                throw context.runtime.newIOError(ie.getLocalizedMessage());
+            }
+
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject close(ThreadContext context) {
+            try {
+                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 selector.isOpen() ? runtime.getFalse() : runtime.getTrue();
+        }
+
+        @JRubyMethod
+        public IRubyObject register(ThreadContext context, IRubyObject io, IRubyObject interests) {
+            Ruby runtime = context.getRuntime();
+            Channel raw_channel = RubyIO.convertToIO(context, io).getChannel();
+
+            if(!(raw_channel instanceof SelectableChannel)) {
+                throw runtime.newArgumentError("not a selectable IO object");
+            }
+
+            SelectableChannel channel = (SelectableChannel)raw_channel;
+
+            try {
+                channel.configureBlocking(false);
+            } catch(IOException ie) {
+                throw runtime.newIOError(ie.getLocalizedMessage());
+            }
+
+            int interestOps = Nio4r.symbolToInterestOps(runtime, channel, interests);
+            SelectionKey key;
+
+            try {
+                key = channel.register(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 raw_channel = RubyIO.convertToIO(context, io).getChannel();
+
+            if(!(raw_channel instanceof SelectableChannel)) {
+                throw runtime.newArgumentError("not a selectable IO object");
+            }
+
+            SelectableChannel channel = (SelectableChannel)raw_channel;
+            SelectionKey key = channel.keyFor(selector);
+
+            if(key == null)
+                return context.nil;
+
+            Monitor monitor = (Monitor)key.attachment();
+            monitor.close(context);
+
+            return monitor;
+        }
+
+        @JRubyMethod(name = "registered?")
+        public IRubyObject isRegistered(ThreadContext context, IRubyObject io) {
+            Ruby runtime = context.getRuntime();
+            Channel raw_channel = RubyIO.convertToIO(context, io).getChannel();
+
+            if(!(raw_channel instanceof SelectableChannel)) {
+                throw runtime.newArgumentError("not a selectable IO object");
+            }
+
+            SelectableChannel channel = (SelectableChannel)raw_channel;
+            SelectionKey key = channel.keyFor(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();
+            int ready = doSelect(runtime, timeout);
+
+            /* Timeout or wakeup */
+            if(ready <= 0)
+                return context.nil;
+
+            RubyArray array = null;
+            if(!block.isGiven()) {
+                array = runtime.newArray(selector.selectedKeys().size());
+            }
+
+            Iterator selectedKeys = 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;
+            }
+        }
+
+        @JRubyMethod
+        public synchronized IRubyObject select_each(ThreadContext context, Block block) {
+            return select_each(context, context.nil, block);
+        }
+
+        @JRubyMethod
+        public synchronized IRubyObject select_each(ThreadContext context, IRubyObject timeout, Block block) {
+            Ruby runtime = context.getRuntime();
+            int ready = doSelect(runtime, timeout);
+
+            /* Timeout or wakeup */
+            if(ready <= 0)
+                return context.nil;
+
+            Iterator selectedKeys = selector.selectedKeys().iterator();
+            while (selectedKeys.hasNext()) {
+                SelectionKey key = (SelectionKey)selectedKeys.next();
+                processKey(key);
+                selectedKeys.remove();
+                block.call(context, (IRubyObject)key.attachment());
+            }
+
+            return context.nil;
+        }
+
+        private int doSelect(Ruby runtime, IRubyObject timeout) {
+            try {
+                if(timeout.isNil()) {
+                    return selector.select();
+                } else {
+                    double t = RubyNumeric.num2dbl(timeout);
+                    if(t == 0) {
+                        return selector.selectNow();
+                    } else if(t < 0) {
+                        throw runtime.newArgumentError("time interval must be positive");
+                    } else {
+                        return selector.select((long)(t * 1000));
+                    }
+                }
+            } catch(IOException ie) {
+                throw runtime.newIOError(ie.getLocalizedMessage());
+            }
+        }
+
+        // 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(!selector.isOpen()) {
+                throw context.getRuntime().newIOError("selector is closed");
+            }
+
+            selector.wakeup();
+            return context.nil;
+        }
+    }
+
+    public class Monitor extends RubyObject {
+        private SelectionKey key;
+        private RubyIO io;
+        private IRubyObject interests, selector, value, closed;
+
+        public Monitor(final Ruby ruby, RubyClass rubyClass) {
+            super(ruby, rubyClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject selectable, IRubyObject interests, IRubyObject selector) {
+            this.io        = RubyIO.convertToIO(context, selectable);
+            this.interests = interests;
+            this.selector  = selector;
+
+            value  = context.nil;
+            closed = context.getRuntime().getFalse();
+
+            return context.nil;
+        }
+
+        public void setSelectionKey(SelectionKey k) {
+            key = k;
+            key.attach(this);
+        }
+
+        @JRubyMethod
+        public IRubyObject io(ThreadContext context) {
+            return io;
+        }
+
+        @JRubyMethod
+        public IRubyObject selector(ThreadContext context) {
+            return selector;
+        }
+
+        @JRubyMethod
+        public IRubyObject interests(ThreadContext context) {
+            return interests;
+        }
+
+        @JRubyMethod
+        public IRubyObject readiness(ThreadContext context) {
+            return Nio4r.interestOpsToSymbol(context.getRuntime(), key.readyOps());
+        }
+
+        @JRubyMethod(name = "readable?")
+        public IRubyObject isReadable(ThreadContext context) {
+            Ruby runtime  = context.getRuntime();
+            int  readyOps = key.readyOps();
+
+            if((readyOps & SelectionKey.OP_READ) != 0 || (readyOps & SelectionKey.OP_ACCEPT) != 0) {
+                return runtime.getTrue();
+            } else {
+                return runtime.getFalse();
+            }
+        }
+
+        @JRubyMethod(name = {"writable?", "writeable?"})
+        public IRubyObject writable(ThreadContext context) {
+            Ruby runtime  = context.getRuntime();
+            int  readyOps = key.readyOps();
+
+            if((readyOps & SelectionKey.OP_WRITE) != 0 || (readyOps & SelectionKey.OP_CONNECT) != 0) {
+                return runtime.getTrue();
+            } else {
+                return runtime.getFalse();
+            }
+        }
+
+        @JRubyMethod(name = "value")
+        public IRubyObject getValue(ThreadContext context) {
+            return value;
+        }
+
+        @JRubyMethod(name = "value=")
+        public IRubyObject setValue(ThreadContext context, IRubyObject obj) {
+            value = obj;
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject close(ThreadContext context) {
+            key.cancel();
+            closed = context.getRuntime().getTrue();
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "closed?")
+        public IRubyObject isClosed(ThreadContext context) {
+            return closed;
+        }
+    }
+}