nio4r 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b58cda1a26e30cb81ff1b0f6febb43413a4c11f
-  data.tar.gz: 319495e598529456785aa74289742cb87d7d2470
+  metadata.gz: 339fc3cc040e41d266a9f83ab155d903294fcdc5
+  data.tar.gz: 8872185b3bfadc884b36b65ea1a17a2c082d7090
 SHA512:
-  metadata.gz: de267fdf599880196fa3a3431cd20a1ce2d4e6dcec16f57f4161b7b6d05d9f8e2c97651a1a959e16f2cea6de965e30b60842635aa954685666a4a4d5c99402fc
-  data.tar.gz: a580ce6b7edf0e7923f0725e5ae9ebe5a194cbd235fa320b2b04a1c8f794ada1e93200a2fb8c9dedbee1961d73e3767e39ec1bdc6b727939281e5ac687e1ec8a
+  metadata.gz: 73083b74bdcb581449b5b0534209fdd9b1c08059ee946eaf9f8155d72605030c127046a7819d4ed325e0bf3e525c4aec81a41c00b55077f9e5b4629dd147d931
+  data.tar.gz: 44eb8368129b34cfb8780b98334ff8a67029d1751fdfc756ee761cb19c975f55a95c5166a251dba88ea7f587a3441f19650dcb13d936d88c60f847bda9c20d1d

data/.rubocop.yml

@@ -24,6 +24,9 @@ Metrics/CyclomaticComplexity:
 Style/GlobalVars:
   Enabled: false
 
+Style/TrivialAccessors:
+  Enabled: false
+
 #
 # Auto-generated overrides
 #

data/.travis.yml

@@ -1,3 +1,6 @@
+language: ruby
+sudo: false
+
 rvm:
   - 2.0.0
   - 2.1.1

data/CHANGES.md

@@ -1,3 +1,9 @@
+1.2.0 (2015-12-22)
+------------------
+* Add NIO::Monitor#interests= API for changing interests. Contributed by
+  @UpeksheJay as a Google Summer of Code project.
+* Update to libev 4.22
+
 1.1.1 (2015-07-17)
 ------------------
 * Update to libev 4.20

data/ext/libev/Changes

@@ -14,6 +14,16 @@ TODO: embed watchers need updating when fd changes
 TODO: document portability requirements for atomic pointer access
 TODO: document requirements for function pointers and calling conventions.
 
+4.22 Sun Dec 20 22:11:50 CET 2015
+	- when epoll detects unremovable fds in the fd set, rebuild
+          only the epoll descriptor, not the signal pipe, to avoid
+          SIGPIPE in ev_async_send. This doesn't solve it on fork,
+          so document what needs to be done in ev_loop_fork
+          (analyzed by Benjamin Mahler).
+	- remove superfluous sys/timeb.h include on win32
+          (analyzed by Jason Madden).
+        - updated libecb.
+
 4.20 Sat Jun 20 13:01:43 CEST 2015
 	- prefer noexcept over throw () with C++ 11.
         - update ecb.h due to incompatibilities with c11.

data/ext/libev/ev.c

@@ -538,7 +538,7 @@ struct signalfd_siginfo
 #define ECB_H
 
 /* 16 bits major, 16 bits minor */
-#define ECB_VERSION 0x00010004
+#define ECB_VERSION 0x00010005
 
 #ifdef _WIN32
   typedef   signed char   int8_t;
@@ -565,7 +565,7 @@ struct signalfd_siginfo
   #endif
 #else
   #include <inttypes.h>
-  #if UINTMAX_MAX > 0xffffffffU
+  #if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
     #define ECB_PTRSIZE 8
   #else
     #define ECB_PTRSIZE 4
@@ -653,6 +653,10 @@ struct signalfd_siginfo
   #include <builtins.h>
 #endif
 
+#if 1400 <= _MSC_VER
+  #include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
+#endif
+
 #ifndef ECB_MEMORY_FENCE
   #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
     #if __i386 || __i386__
@@ -665,15 +669,23 @@ struct signalfd_siginfo
       #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
     #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("sync"     : : : "memory")
+    #elif defined __ARM_ARCH_2__ \
+      || defined __ARM_ARCH_3__  || defined __ARM_ARCH_3M__  \
+      || defined __ARM_ARCH_4__  || defined __ARM_ARCH_4T__  \
+      || defined __ARM_ARCH_5__  || defined __ARM_ARCH_5E__  \
+      || defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
+      || defined __ARM_ARCH_5TEJ__
+      /* should not need any, unless running old code on newer cpu - arm doesn't support that */
     #elif defined __ARM_ARCH_6__  || defined __ARM_ARCH_6J__  \
-       || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
+       || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
+       || defined __ARM_ARCH_6T2__
       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
     #elif defined __ARM_ARCH_7__  || defined __ARM_ARCH_7A__  \
-       || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
+       || defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("dmb"      : : : "memory")
     #elif __aarch64__
       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("dmb ish"  : : : "memory")
-    #elif (__sparc || __sparc__) && !__sparcv8
+    #elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
       #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad"                            : : : "memory")
       #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore             | #StoreStore")
@@ -921,6 +933,11 @@ typedef int ecb_bool;
   ecb_function_ ecb_const int
   ecb_ctz32 (uint32_t x)
   {
+#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
+    unsigned long r;
+    _BitScanForward (&r, x);
+    return (int)r;
+#else
     int r = 0;
 
     x &= ~x + 1; /* this isolates the lowest bit */
@@ -940,14 +957,21 @@ typedef int ecb_bool;
 #endif
 
     return r;
+#endif
   }
 
   ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
   ecb_function_ ecb_const int
   ecb_ctz64 (uint64_t x)
   {
-    int shift = x & 0xffffffffU ? 0 : 32;
+#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
+    unsigned long r;
+    _BitScanForward64 (&r, x);
+    return (int)r;
+#else
+    int shift = x & 0xffffffff ? 0 : 32;
     return ecb_ctz32 (x >> shift) + shift;
+#endif
   }
 
   ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
@@ -965,6 +989,11 @@ typedef int ecb_bool;
   ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
   ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
   {
+#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
+    unsigned long r;
+    _BitScanReverse (&r, x);
+    return (int)r;
+#else
     int r = 0;
 
     if (x >> 16) { x >>= 16; r += 16; }
@@ -974,16 +1003,23 @@ typedef int ecb_bool;
     if (x >>  1) {           r +=  1; }
 
     return r;
+#endif
   }
 
   ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
   ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
   {
+#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
+    unsigned long r;
+    _BitScanReverse64 (&r, x);
+    return (int)r;
+#else
     int r = 0;
 
     if (x >> 32) { x >>= 32; r += 32; }
 
     return r + ecb_ld32 (x);
+#endif
   }
 #endif
 
@@ -1096,8 +1132,8 @@ ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { retu
 /* try to tell the compiler that some condition is definitely true */
 #define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
 
-ecb_inline ecb_const unsigned char ecb_byteorder_helper (void);
-ecb_inline ecb_const unsigned char
+ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
+ecb_inline ecb_const uint32_t
 ecb_byteorder_helper (void)
 {
   /* the union code still generates code under pressure in gcc, */
@@ -1106,26 +1142,28 @@ ecb_byteorder_helper (void)
   /* the reason why we have this horrible preprocessor mess */
   /* is to avoid it in all cases, at least on common architectures */
   /* or when using a recent enough gcc version (>= 4.6) */
-#if ((__i386 || __i386__) && !__VOS__) || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64
-  return 0x44;
-#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-  return 0x44;
-#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-  return 0x11;
+#if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
+    || ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
+  #define ECB_LITTLE_ENDIAN 1
+  return 0x44332211;
+#elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
+      || ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
+  #define ECB_BIG_ENDIAN 1
+  return 0x11223344;
 #else
   union
   {
-    uint32_t i;
-    uint8_t c;
-  } u = { 0x11223344 };
-  return u.c;
+    uint8_t c[4];
+    uint32_t u;
+  } u = { 0x11, 0x22, 0x33, 0x44 };
+  return u.u;
 #endif
 }
 
 ecb_inline ecb_const ecb_bool ecb_big_endian    (void);
-ecb_inline ecb_const ecb_bool ecb_big_endian    (void) { return ecb_byteorder_helper () == 0x11; }
+ecb_inline ecb_const ecb_bool ecb_big_endian    (void) { return ecb_byteorder_helper () == 0x11223344; }
 ecb_inline ecb_const ecb_bool ecb_little_endian (void);
-ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
+ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
 
 #if ECB_GCC_VERSION(3,0) || ECB_C99
   #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
@@ -1160,6 +1198,102 @@ ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_he
   #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
 #endif
 
+ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
+ecb_function_ ecb_const uint32_t
+ecb_binary16_to_binary32 (uint32_t x)
+{
+  unsigned int s = (x & 0x8000) << (31 - 15);
+  int          e = (x >> 10) & 0x001f;
+  unsigned int m =  x        & 0x03ff;
+
+  if (ecb_expect_false (e == 31))
+    /* infinity or NaN */
+    e = 255 - (127 - 15);
+  else if (ecb_expect_false (!e))
+    {
+      if (ecb_expect_true (!m))
+        /* zero, handled by code below by forcing e to 0 */
+        e = 0 - (127 - 15);
+      else
+        {
+          /* subnormal, renormalise */
+          unsigned int s = 10 - ecb_ld32 (m);
+
+          m = (m << s) & 0x3ff; /* mask implicit bit */
+          e -= s - 1;
+        }
+    }
+
+  /* e and m now are normalised, or zero, (or inf or nan) */
+  e += 127 - 15;
+
+  return s | (e << 23) | (m << (23 - 10));
+}
+
+ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
+ecb_function_ ecb_const uint16_t
+ecb_binary32_to_binary16 (uint32_t x)
+{
+  unsigned int s =  (x >> 16) & 0x00008000; /* sign bit, the easy part */
+  unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
+  unsigned int m =   x        & 0x007fffff;
+
+  x &= 0x7fffffff;
+
+  /* if it's within range of binary16 normals, use fast path */
+  if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
+    {
+      /* mantissa round-to-even */
+      m += 0x00000fff + ((m >> (23 - 10)) & 1);
+
+      /* handle overflow */
+      if (ecb_expect_false (m >= 0x00800000))
+        {
+          m >>= 1;
+          e +=  1;
+        }
+
+      return s | (e << 10) | (m >> (23 - 10));
+    }
+
+  /* handle large numbers and infinity */
+  if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
+    return s | 0x7c00;
+
+  /* handle zero, subnormals and small numbers */
+  if (ecb_expect_true (x < 0x38800000))
+    {
+      /* zero */
+      if (ecb_expect_true (!x))
+        return s;
+
+      /* handle subnormals */
+
+      /* too small, will be zero */
+      if (e < (14 - 24)) /* might not be sharp, but is good enough */
+        return s;
+
+      m |= 0x00800000; /* make implicit bit explicit */
+
+      /* very tricky - we need to round to the nearest e (+10) bit value */
+      {
+        unsigned int bits = 14 - e;
+        unsigned int half = (1 << (bits - 1)) - 1;
+        unsigned int even = (m >> bits) & 1;
+
+        /* if this overflows, we will end up with a normalised number */
+        m = (m + half + even) >> bits;
+      }
+
+      return s | m;
+    }
+
+  /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
+  m >>= 13;
+
+  return s | 0x7c00 | m | !m;
+}
+
 /*******************************************************************************/
 /* floating point stuff, can be disabled by defining ECB_NO_LIBM */
 
@@ -1211,23 +1345,6 @@ ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_he
     #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
   #endif
 
-  /* converts an ieee half/binary16 to a float */
-  ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
-  ecb_function_ ecb_const float
-  ecb_binary16_to_float (uint16_t x)
-  {
-    int e = (x >> 10) & 0x1f;
-    int m = x & 0x3ff;
-    float r;
-
-    if      (!e     ) r = ecb_ldexpf (m        ,    -24);
-    else if (e != 31) r = ecb_ldexpf (m + 0x400, e - 25);
-    else if (m      ) r = ECB_NAN;
-    else              r = ECB_INFINITY;
-
-    return x & 0x8000 ? -r : r;
-  }
-
   /* convert a float to ieee single/binary32 */
   ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
   ecb_function_ ecb_const uint32_t
@@ -1368,6 +1485,22 @@ ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_he
     return r;
   }
 
+  /* convert a float to ieee half/binary16 */
+  ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
+  ecb_function_ ecb_const uint16_t
+  ecb_float_to_binary16 (float x)
+  {
+    return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
+  }
+
+  /* convert an ieee half/binary16 to float */
+  ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
+  ecb_function_ ecb_const float
+  ecb_binary16_to_float (uint16_t x)
+  {
+    return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
+  }
+
 #endif
 
 #endif
@@ -2922,7 +3055,7 @@ loop_fork (EV_P)
 #endif
 
 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
-  if (ev_is_active (&pipe_w))
+  if (ev_is_active (&pipe_w) && postfork != 2)
     {
       /* pipe_write_wanted must be false now, so modifying fd vars should be safe */
 

data/ext/libev/ev.h

@@ -211,7 +211,7 @@ struct ev_loop;
 /*****************************************************************************/
 
 #define EV_VERSION_MAJOR 4
-#define EV_VERSION_MINOR 20
+#define EV_VERSION_MINOR 22
 
 /* eventmask, revents, events... */
 enum {

data/ext/libev/ev_epoll.c

@@ -179,7 +179,7 @@ epoll_poll (EV_P_ ev_tstamp timeout)
       if (expect_false ((uint32_t)anfds [fd].egen != (uint32_t)(ev->data.u64 >> 32)))
         {
           /* recreate kernel state */
-          postfork = 1;
+          postfork |= 2;
           continue;
         }
 
@@ -203,7 +203,7 @@ epoll_poll (EV_P_ ev_tstamp timeout)
           /* which is fortunately easy to do for us. */
           if (epoll_ctl (backend_fd, want ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, fd, ev))
             {
-              postfork = 1; /* an error occurred, recreate kernel state */
+              postfork |= 2; /* an error occurred, recreate kernel state */
               continue;
             }
         }

data/ext/libev/ev_win32.c

@@ -39,9 +39,6 @@
 
 #ifdef _WIN32
 
-/* timeb.h is actually xsi legacy functionality */
-#include <sys/timeb.h>
-
 /* note: the comment below could not be substantiated, but what would I care */
 /* MSDN says this is required to handle SIGFPE */
 /* my wild guess would be that using something floating-pointy is required */
@@ -91,6 +88,8 @@ ev_pipe (int filedes [2])
   if (connect (sock [0], (struct sockaddr *)&addr, addr_size))
     goto fail;
 
+  /* TODO: returns INVALID_SOCKET on winsock accept, not < 0. fix it */
+  /* when convenient, probably by just removing error checking altogether? */
   if ((sock [1] = accept (listener, 0, 0)) < 0)
     goto fail;
 

data/ext/nio4r/monitor.c

@@ -15,6 +15,8 @@ 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_set_interests(VALUE self, VALUE interests);
+
 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);
@@ -40,6 +42,7 @@ 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, "interests=", NIO_Monitor_set_interests, 1);
     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);
@@ -117,6 +120,38 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE
     return Qnil;
 }
 
+static VALUE NIO_Monitor_set_interests(VALUE self, VALUE interests)
+{
+    struct NIO_Monitor *monitor;
+    ID interests_id;
+
+    if(NIO_Monitor_is_closed(self) == Qtrue) {
+        rb_raise(rb_eTypeError, "monitor is already closed");
+    }
+
+    interests_id = SYM2ID(interests);
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    if(interests_id == rb_intern("r")) {
+        monitor->interests = EV_READ;
+    } else if(interests_id == rb_intern("w")) {
+        monitor->interests = EV_WRITE;
+    } else if(interests_id == rb_intern("rw")) {
+        monitor->interests = EV_READ | EV_WRITE;
+    } else {
+        rb_raise(rb_eArgError, "invalid interest type %s (must be :r, :w, or :rw)",
+            RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0, 0)));
+    }
+
+    ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
+    ev_io_set(&monitor->ev_io, monitor->ev_io.fd, monitor->interests);
+    ev_io_start(monitor->selector->ev_loop, &monitor->ev_io);
+
+    rb_ivar_set(self, rb_intern("interests"), interests);
+
+    return interests;
+}
+
 static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self)
 {
     VALUE deregister, selector;
@@ -127,10 +162,11 @@ static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self)
     selector = rb_ivar_get(self, rb_intern("selector"));
 
     if(selector != Qnil) {
-        /* if ev_loop is 0, it means that the loop has been stopped already (see NIO_Selector_shutdown)*/
+        /* if ev_loop is 0, it means that the loop has been stopped already (see NIO_Selector_shutdown) */
         if(monitor->selector->ev_loop != 0) {
           ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
         }
+
         monitor->selector = 0;
         rb_ivar_set(self, rb_intern("selector"), Qnil);
     
@@ -148,7 +184,7 @@ static VALUE NIO_Monitor_is_closed(VALUE self)
     struct NIO_Monitor *monitor;
     Data_Get_Struct(self, struct NIO_Monitor, monitor);
 
-    return !monitor->selector;
+    return monitor->selector == 0 ? Qtrue : Qfalse;
 }
 
 static VALUE NIO_Monitor_io(VALUE self)

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

@@ -235,6 +235,11 @@ public class Nio4r implements Library {
         @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");
+            }
+
             int ready = doSelect(runtime, context, timeout);
 
             /* Timeout or wakeup */
@@ -353,6 +358,36 @@ public class Nio4r implements Library {
             key.attach(this);
         }
 
+        @JRubyMethod(name = "interests=")
+        public IRubyObject setInterests(ThreadContext context, IRubyObject interests) {
+            if(this.closed == context.getRuntime().getTrue()) {
+                throw context.getRuntime().newTypeError("monitor is already closed");
+            }
+
+            int interestOps = 0;
+            Ruby runtime = context.getRuntime();
+            Channel rawChannel = io.getChannel();
+            SelectableChannel channel = (SelectableChannel)rawChannel;
+
+            this.interests = interests;
+
+            if(interests == ruby.newSymbol("r")) {
+                interestOps = SelectionKey.OP_READ;
+            } else if(interests == ruby.newSymbol("w")) {
+                interestOps = SelectionKey.OP_WRITE;
+            } else if(interests == ruby.newSymbol("rw")) {
+                interestOps = SelectionKey.OP_READ|SelectionKey.OP_WRITE;
+            }
+
+            if((interestOps & ~(channel.validOps())) == 0) {
+                key.interestOps(interestOps);
+            } else {
+                throw context.getRuntime().newArgumentError("given interests not supported for this IO object");
+            }
+
+            return this.interests;
+        }
+
         @JRubyMethod
         public IRubyObject io(ThreadContext context) {
             return io;

data/ext/nio4r/selector.c

@@ -297,6 +297,11 @@ static VALUE NIO_Selector_select_synchronized(VALUE *args)
     struct NIO_Selector *selector;
 
     Data_Get_Struct(args[0], struct NIO_Selector, selector);
+
+    if(selector->closed) {
+        rb_raise(rb_eIOError, "selector is closed");
+    }
+
     if(!rb_block_given_p()) {
         selector->ready_array = rb_ary_new();
     }

data/lib/nio/monitor.rb

@@ -22,6 +22,14 @@ module NIO
       @closed    = false
     end
 
+    # set the interests set
+    def interests=(interests)
+      fail TypeError, "monitor is already closed" if closed?
+      fail ArgumentError, "bad interests: #{interests}" unless [:r, :w, :rw].include?(interests)
+
+      @interests = interests
+    end
+
     # Is the IO object readable?
     def readable?
       readiness == :r || readiness == :rw

data/lib/nio/selector.rb

@@ -78,11 +78,10 @@ module NIO
 
         ready_writers.each do |io|
           monitor = @selectables[io]
-          monitor.readiness = case monitor.readiness
-          when :r
-            :rw
+          if monitor.readiness == :r
+            monitor.readiness = :rw
           else
-            :w
+            monitor.readiness = :w
           end
           selected_monitors << monitor
         end

data/lib/nio/version.rb

@@ -1,3 +1,3 @@
 module NIO
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/spec/nio/monitor_spec.rb

@@ -1,20 +1,49 @@
 require "spec_helper"
+require "socket"
 
 RSpec.describe NIO::Monitor do
-  let(:pipes) { IO.pipe }
-  let(:reader) { pipes.first }
-  let(:writer) { pipes.last }
+  let(:example_peers) do
+    address   = "127.0.0.1"
+    base_port = 12_345
+    tries     = 10
+
+    server = tries.times do |n|
+      begin
+        break TCPServer.new(address, base_port + n)
+      rescue Errno::EADDRINUSE
+        retry
+      end
+    end
+
+    fail Errno::EADDRINUSE, "couldn't find an open port" unless server
+    client = TCPSocket.new(address, server.addr[1])
+    [server, client]
+  end
+
+  let(:reader) { example_peers.first }
+  let(:writer) { example_peers.last }
+
   let(:selector) { NIO::Selector.new }
 
   subject    { selector.register(reader, :r) }
   let(:peer) { selector.register(writer, :rw) }
   after      { selector.close }
 
+  before     { example_peers } # open server and client automatically
+  after      { reader.close }
+  after      { writer.close }
+
   it "knows its interests" do
     expect(subject.interests).to eq(:r)
     expect(peer.interests).to eq(:rw)
   end
 
+  it "changes the interest set" do
+    expect(peer.interests).not_to eq(:w)
+    peer.interests = :w
+    expect(peer.interests).to eq(:w)
+  end
+
   it "knows its IO object" do
     expect(subject.io).to eq(reader)
   end
@@ -34,14 +63,13 @@ RSpec.describe NIO::Monitor do
     writer_monitor = peer
 
     selected = selector.select(0)
-    expect(selected).not_to include(reader_monitor)
     expect(selected).to include(writer_monitor)
 
     expect(writer_monitor.readiness).to eq(:w)
     expect(writer_monitor).not_to be_readable
     expect(writer_monitor).to be_writable
 
-    writer << "loldata"
+    writer << "testing 1 2 3"
 
     selected = selector.select(0)
     expect(selected).to include(reader_monitor)
@@ -51,6 +79,14 @@ RSpec.describe NIO::Monitor do
     expect(reader_monitor).not_to be_writable
   end
 
+  it "changes current interests with #interests=" do
+    client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+    monitor = selector.register(client, :r)
+    expect(monitor.interests).to eq(:r)
+    monitor.interests = :w
+    expect(monitor.interests).to eq(:w)
+  end
+
   it "closes" do
     expect(subject).not_to be_closed
     expect(selector.registered?(reader)).to be_truthy
@@ -67,4 +103,11 @@ RSpec.describe NIO::Monitor do
     subject.close
     expect(subject).to be_closed
   end
+
+  it "changes the interest set after monitor closed" do
+    # check for changing the interests on the go after closed expected to fail
+    expect(subject.interests).not_to eq(:rw)
+    subject.close # forced shutdown
+    expect { subject.interests = :rw }.to raise_error(TypeError)
+  end
 end

data/spec/nio/selectables/tcp_socket_spec.rb

@@ -80,7 +80,7 @@ RSpec.describe TCPSocket do
         client.connect_nonblock Socket.sockaddr_in(tcp_port, "127.0.0.1")
       end.to raise_exception Errno::EINPROGRESS
 
-      expect(selector.select(0)).to include monitor
+      expect(selector.select(0.001)).to include monitor
       result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
       expect(result.unpack("i").first).to be_zero
     end

data/spec/nio/selector_spec.rb

@@ -161,6 +161,12 @@ RSpec.describe NIO::Selector do
       expect(readables).to include monitor2
       expect(readables).not_to include monitor3
     end
+
+    it "raises IOError if asked to select on a closed selector" do
+      subject.close
+
+      expect { subject.select(0) }.to raise_exception IOError
+    end
   end
 
   it "closes" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nio4r
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-18 00:00:00.000000000 Z
+date: 2015-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: NIO provides a high performance selector API for monitoring IO objects