nio4r 2.5.2-java → 2.5.7-java

data/ext/nio4r/nio4r.h

@@ -6,12 +6,11 @@
 #ifndef NIO4R_H
 #define NIO4R_H
 
+#include "libev.h"
 #include "ruby.h"
 #include "ruby/io.h"
-#include "libev.h"
 
-struct NIO_Selector
-{
+struct NIO_Selector {
     struct ev_loop *ev_loop;
     struct ev_timer timer; /* for timeouts */
     struct ev_io wakeup;
@@ -24,31 +23,27 @@ struct NIO_Selector
     VALUE ready_array;
 };
 
-struct NIO_callback_data
-{
+struct NIO_callback_data {
     VALUE *monitor;
     struct NIO_Selector *selector;
 };
 
-struct NIO_Monitor
-{
+struct NIO_Monitor {
     VALUE self;
     int interests, revents;
     struct ev_io ev_io;
     struct NIO_Selector *selector;
 };
 
-struct NIO_ByteBuffer
-{
+struct NIO_ByteBuffer {
     char *buffer;
     int position, limit, capacity, mark;
 };
 
-
 #ifdef GetReadFile
-# define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
+#define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
 #else
-# define FPTR_TO_FD(fptr) fptr->fd
+#define FPTR_TO_FD(fptr) fptr->fd
 #endif /* GetReadFile */
 
 /* Thunk between libev callbacks in NIO::Monitors and NIO::Selectors */

data/ext/nio4r/org/nio4r/ByteBuffer.java

@@ -1,6 +1,7 @@
 package org.nio4r;
 
 import java.io.IOException;
+import java.io.Serializable;
 import java.nio.channels.Channel;
 import java.nio.channels.SelectableChannel;
 import java.nio.channels.ReadableByteChannel;
@@ -25,6 +26,7 @@ import org.jruby.runtime.Block;
 created by Upekshej
  */
 public class ByteBuffer extends RubyObject {
+    private static final long serialVersionUID = -6903439483039149324L;
     private java.nio.ByteBuffer byteBuffer;
 
     public static RaiseException newOverflowError(ThreadContext context, String message) {

data/ext/nio4r/org/nio4r/Monitor.java

@@ -13,6 +13,7 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 public class Monitor extends RubyObject {
+    private static final long serialVersionUID = -3733782997115074794L;
     private SelectionKey key;
     private RubyIO io;
     private IRubyObject interests, selector, value, closed;

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

@@ -7,7 +7,6 @@ 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;
@@ -21,9 +20,8 @@ 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 static final long serialVersionUID = -14562818539414873L;
     private java.nio.channels.Selector selector;
     private HashMap<SelectableChannel,SelectionKey> cancelledKeys;
     private volatile boolean wakeupFired;
@@ -45,7 +43,7 @@ public class Selector extends RubyObject {
 
     @JRubyMethod
     public IRubyObject initialize(ThreadContext context, IRubyObject backend) {
-        if(backend != context.runtime.newSymbol("java")) {
+        if(backend != context.runtime.newSymbol("java") && !backend.isNil()) {
             throw context.runtime.newArgumentError(":java is the only supported backend");
         }
 
@@ -203,15 +201,15 @@ public class Selector extends RubyObject {
             return context.nil;
         }
 
-        RubyArray array = null;
+        RubyArray<?> array = null;
 
         if(!block.isGiven()) {
             array = runtime.newArray(this.selector.selectedKeys().size());
         }
 
-        Iterator selectedKeys = this.selector.selectedKeys().iterator();
+        Iterator<SelectionKey> selectedKeys = this.selector.selectedKeys().iterator();
         while(selectedKeys.hasNext()) {
-            SelectionKey key = (SelectionKey)selectedKeys.next();
+            SelectionKey key = selectedKeys.next();
             processKey(key);
 
             selectedKeys.remove();
@@ -263,10 +261,10 @@ public class Selector extends RubyObject {
 
     /* Flush our internal buffer of cancelled keys */
     private void cancelKeys() {
-        Iterator cancelledKeys = this.cancelledKeys.entrySet().iterator();
+        Iterator<Map.Entry<SelectableChannel, SelectionKey>> cancelledKeys = this.cancelledKeys.entrySet().iterator();
         while(cancelledKeys.hasNext()) {
-            Map.Entry entry = (Map.Entry)cancelledKeys.next();
-            SelectionKey key = (SelectionKey)entry.getValue();
+            Map.Entry<SelectableChannel, SelectionKey> entry = cancelledKeys.next();
+            SelectionKey key = entry.getValue();
             key.cancel();
             cancelledKeys.remove();
         }

data/ext/nio4r/selector.c

@@ -5,7 +5,7 @@
 
 #include "nio4r.h"
 #ifdef HAVE_RUBYSIG_H
-# include "rubysig.h"
+#include "rubysig.h"
 #endif
 
 #ifdef HAVE_UNISTD_H
@@ -14,11 +14,11 @@
 #include <io.h>
 #endif
 
-#include <fcntl.h>
 #include <assert.h>
+#include <fcntl.h>
 
 static VALUE mNIO = Qnil;
-static VALUE cNIO_Monitor  = Qnil;
+static VALUE cNIO_Monitor = Qnil;
 static VALUE cNIO_Selector = Qnil;
 
 /* Allocator/deallocator */
@@ -80,7 +80,7 @@ void Init_NIO_Selector()
     rb_define_method(cNIO_Selector, "closed?", NIO_Selector_closed, 0);
     rb_define_method(cNIO_Selector, "empty?", NIO_Selector_is_empty, 0);
 
-    cNIO_Monitor = rb_define_class_under(mNIO, "Monitor",  rb_cObject);
+    cNIO_Monitor = rb_define_class_under(mNIO, "Monitor", rb_cObject);
 }
 
 /* Create the libev event loop and incoming event buffer */
@@ -95,13 +95,12 @@ static VALUE NIO_Selector_allocate(VALUE klass)
        safety. Pipes are nice and safe to use between threads.
 
        Note that Java NIO uses this same mechanism */
-    if(pipe(fds) < 0) {
+    if (pipe(fds) < 0) {
         rb_sys_fail("pipe");
     }
 
     /* 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) {
+    if (fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0 || fcntl(fds[1], F_SETFL, O_NONBLOCK) < 0) {
         rb_sys_fail("fcntl");
     }
 
@@ -127,7 +126,7 @@ static VALUE NIO_Selector_allocate(VALUE klass)
 /* NIO selectors store all Ruby objects in instance variables so mark is a stub */
 static void NIO_Selector_mark(struct NIO_Selector *selector)
 {
-    if(selector->ready_array != Qnil) {
+    if (selector->ready_array != Qnil) {
         rb_gc_mark(selector->ready_array);
     }
 }
@@ -136,14 +135,14 @@ static void NIO_Selector_mark(struct NIO_Selector *selector)
    Called by both NIO::Selector#close and the finalizer below */
 static void NIO_Selector_shutdown(struct NIO_Selector *selector)
 {
-    if(selector->closed) {
+    if (selector->closed) {
         return;
     }
 
     close(selector->wakeup_reader);
     close(selector->wakeup_writer);
 
-    if(selector->ev_loop) {
+    if (selector->ev_loop) {
         ev_loop_destroy(selector->ev_loop);
         selector->ev_loop = 0;
     }
@@ -159,30 +158,39 @@ static void NIO_Selector_free(struct NIO_Selector *selector)
 }
 
 /* Return an array of symbols for supported backends */
-static VALUE NIO_Selector_supported_backends(VALUE klass) {
+static VALUE NIO_Selector_supported_backends(VALUE klass)
+{
     unsigned int backends = ev_supported_backends();
     VALUE result = rb_ary_new();
 
-    if(backends & EVBACKEND_EPOLL) {
+    if (backends & EVBACKEND_EPOLL) {
         rb_ary_push(result, ID2SYM(rb_intern("epoll")));
     }
 
-    if(backends & EVBACKEND_POLL) {
+    if (backends & EVBACKEND_POLL) {
         rb_ary_push(result, ID2SYM(rb_intern("poll")));
     }
 
-    if(backends & EVBACKEND_KQUEUE) {
+    if (backends & EVBACKEND_KQUEUE) {
         rb_ary_push(result, ID2SYM(rb_intern("kqueue")));
     }
 
-    if(backends & EVBACKEND_SELECT) {
+    if (backends & EVBACKEND_SELECT) {
         rb_ary_push(result, ID2SYM(rb_intern("select")));
     }
 
-    if(backends & EVBACKEND_PORT) {
+    if (backends & EVBACKEND_PORT) {
         rb_ary_push(result, ID2SYM(rb_intern("port")));
     }
 
+    if (backends & EVBACKEND_LINUXAIO) {
+        rb_ary_push(result, ID2SYM(rb_intern("linuxaio")));
+    }
+
+    if (backends & EVBACKEND_IOURING) {
+        rb_ary_push(result, ID2SYM(rb_intern("io_uring")));
+    }
+
     return result;
 }
 
@@ -201,27 +209,29 @@ static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
 
     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)));
+    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")) {
+        if (backend_id == rb_intern("epoll")) {
             flags = EVBACKEND_EPOLL;
-        } else if(backend_id == rb_intern("poll")) {
+        } else if (backend_id == rb_intern("poll")) {
             flags = EVBACKEND_POLL;
-        } else if(backend_id == rb_intern("kqueue")) {
+        } else if (backend_id == rb_intern("kqueue")) {
             flags = EVBACKEND_KQUEUE;
-        } else if(backend_id == rb_intern("select")) {
+        } else if (backend_id == rb_intern("select")) {
             flags = EVBACKEND_SELECT;
-        } else if(backend_id == rb_intern("port")) {
+        } else if (backend_id == rb_intern("port")) {
             flags = EVBACKEND_PORT;
+        } else if (backend_id == rb_intern("linuxaio")) {
+            flags = EVBACKEND_LINUXAIO;
+        } else if (backend_id == rb_intern("io_uring")) {
+            flags = EVBACKEND_IOURING;
         } else {
-            rb_raise(rb_eArgError, "unsupported backend: %s",
-                RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
+            rb_raise(rb_eArgError, "unsupported backend: %s", RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
         }
     }
 
@@ -229,7 +239,7 @@ static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
     assert(!selector->ev_loop);
 
     selector->ev_loop = ev_loop_new(flags);
-    if(!selector->ev_loop) {
+    if (!selector->ev_loop) {
         rb_raise(rb_eIOError, "error initializing event loop");
     }
 
@@ -245,11 +255,12 @@ static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
     return Qnil;
 }
 
-static VALUE NIO_Selector_backend(VALUE self) {
+static VALUE NIO_Selector_backend(VALUE self)
+{
     struct NIO_Selector *selector;
 
     Data_Get_Struct(self, struct NIO_Selector, selector);
-    if(selector->closed) {
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
@@ -264,6 +275,10 @@ static VALUE NIO_Selector_backend(VALUE self) {
             return ID2SYM(rb_intern("select"));
         case EVBACKEND_PORT:
             return ID2SYM(rb_intern("port"));
+        case EVBACKEND_LINUXAIO:
+            return ID2SYM(rb_intern("linuxaio"));
+        case EVBACKEND_IOURING:
+            return ID2SYM(rb_intern("io_uring"));
     }
 
     return ID2SYM(rb_intern("unknown"));
@@ -277,7 +292,7 @@ static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VA
     current_thread = rb_thread_current();
     lock_holder = rb_ivar_get(self, rb_intern("lock_holder"));
 
-    if(lock_holder != current_thread) {
+    if (lock_holder != current_thread) {
         lock = rb_ivar_get(self, rb_intern("lock"));
         rb_funcall(lock, rb_intern("lock"), 0);
         rb_ivar_set(self, rb_intern("lock_holder"), current_thread);
@@ -306,7 +321,7 @@ static VALUE NIO_Selector_unlock(VALUE self)
 /* Register an IO object with the selector for the given interests */
 static VALUE NIO_Selector_register(VALUE self, VALUE io, VALUE interests)
 {
-    VALUE args[3] = {self, io, interests};
+    VALUE args[3] = { self, io, interests };
     return NIO_Selector_synchronize(self, NIO_Selector_register_synchronized, args);
 }
 
@@ -322,14 +337,14 @@ static VALUE NIO_Selector_register_synchronized(VALUE *args)
     interests = args[2];
 
     Data_Get_Struct(self, struct NIO_Selector, selector);
-    if(selector->closed) {
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
     selectables = rb_ivar_get(self, rb_intern("selectables"));
     monitor = rb_hash_lookup(selectables, io);
 
-    if(monitor != Qnil)
+    if (monitor != Qnil)
         rb_raise(rb_eArgError, "this IO is already registered with selector");
 
     /* Create a new NIO::Monitor */
@@ -346,7 +361,7 @@ static VALUE NIO_Selector_register_synchronized(VALUE *args)
 /* Deregister an IO object from the selector */
 static VALUE NIO_Selector_deregister(VALUE self, VALUE io)
 {
-    VALUE args[2] = {self, io};
+    VALUE args[2] = { self, io };
     return NIO_Selector_synchronize(self, NIO_Selector_deregister_synchronized, args);
 }
 
@@ -361,7 +376,7 @@ static VALUE NIO_Selector_deregister_synchronized(VALUE *args)
     selectables = rb_ivar_get(self, rb_intern("selectables"));
     monitor = rb_hash_delete(selectables, io);
 
-    if(monitor != Qnil) {
+    if (monitor != Qnil) {
         rb_funcall(monitor, rb_intern("close"), 1, Qfalse);
     }
 
@@ -385,7 +400,7 @@ static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "01", &timeout);
 
-    if(timeout != Qnil && NUM2DBL(timeout) < 0) {
+    if (timeout != Qnil && NUM2DBL(timeout) < 0) {
         rb_raise(rb_eArgError, "time interval must be positive");
     }
 
@@ -404,26 +419,26 @@ static VALUE NIO_Selector_select_synchronized(VALUE *args)
 
     Data_Get_Struct(args[0], struct NIO_Selector, selector);
 
-    if(selector->closed) {
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
-    if(!rb_block_given_p()) {
+    if (!rb_block_given_p()) {
         selector->ready_array = rb_ary_new();
     }
 
     ready = NIO_Selector_run(selector, args[1]);
 
     /* Timeout */
-    if(ready < 0) {
-        if(!rb_block_given_p()) {
+    if (ready < 0) {
+        if (!rb_block_given_p()) {
             selector->ready_array = Qnil;
         }
 
         return Qnil;
     }
 
-    if(rb_block_given_p()) {
+    if (rb_block_given_p()) {
         return INT2NUM(ready);
     } else {
         ready_array = selector->ready_array;
@@ -441,12 +456,12 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     selector->selecting = 1;
     selector->wakeup_fired = 0;
 
-    if(timeout == Qnil) {
+    if (timeout == Qnil) {
         /* Don't fire a wakeup timeout if we weren't passed one */
         ev_timer_stop(selector->ev_loop, &selector->timer);
     } else {
         timeout_val = NUM2DBL(timeout);
-        if(timeout_val == 0) {
+        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;
@@ -462,7 +477,7 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     result = selector->ready_count;
     selector->selecting = selector->ready_count = 0;
 
-    if(result > 0 || selector->wakeup_fired) {
+    if (result > 0 || selector->wakeup_fired) {
         selector->wakeup_fired = 0;
         return result;
     } else {
@@ -476,7 +491,7 @@ static VALUE NIO_Selector_wakeup(VALUE self)
     struct NIO_Selector *selector;
     Data_Get_Struct(self, struct NIO_Selector, selector);
 
-    if(selector->closed) {
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
@@ -489,7 +504,7 @@ static VALUE NIO_Selector_wakeup(VALUE self)
 /* Close the selector and free system resources */
 static VALUE NIO_Selector_close(VALUE self)
 {
-    VALUE args[1] = {self};
+    VALUE args[1] = { self };
     return NIO_Selector_synchronize(self, NIO_Selector_close_synchronized, args);
 }
 
@@ -507,7 +522,7 @@ static VALUE NIO_Selector_close_synchronized(VALUE *args)
 /* Is the selector closed? */
 static VALUE NIO_Selector_closed(VALUE self)
 {
-    VALUE args[1] = {self};
+    VALUE args[1] = { self };
     return NIO_Selector_synchronize(self, NIO_Selector_closed_synchronized, args);
 }
 
@@ -528,7 +543,6 @@ static VALUE NIO_Selector_is_empty(VALUE self)
     return rb_funcall(selectables, rb_intern("empty?"), 0) == Qtrue ? Qtrue : Qfalse;
 }
 
-
 /* 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)
 {
@@ -542,7 +556,8 @@ static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *
     selector->selecting = 0;
 
     /* Drain the wakeup pipe, giving us level-triggered behavior */
-    while(read(selector->wakeup_reader, buffer, 128) > 0);
+    while (read(selector->wakeup_reader, buffer, 128) > 0)
+        ;
 }
 
 /* libev callback fired whenever a monitor gets an event */
@@ -558,7 +573,7 @@ void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, in
     selector->ready_count++;
     monitor_data->revents = revents;
 
-    if(rb_block_given_p()) {
+    if (rb_block_given_p()) {
         rb_yield(monitor);
     } else {
         assert(selector->ready_array != Qnil);