nio4r 0.2.0 → 2.7.5

data/ext/nio4r/monitor.c

@@ -11,28 +11,39 @@ static VALUE cNIO_Monitor = Qnil;
 
 /* Allocator/deallocator */
 static VALUE NIO_Monitor_allocate(VALUE klass);
-static void NIO_Monitor_mark(struct NIO_Monitor *monitor);
-static void NIO_Monitor_free(struct NIO_Monitor *monitor);
+static void NIO_Monitor_mark(void *data);
+static size_t NIO_Monitor_memsize(const void *data);
 
 /* 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_set_interests(VALUE self, VALUE interests);
+static VALUE NIO_Monitor_add_interest(VALUE self, VALUE interest);
+static VALUE NIO_Monitor_remove_interest(VALUE self, VALUE interest);
+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);
 static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj);
 static VALUE NIO_Monitor_readiness(VALUE self);
 
-/* Internal functions */
-static void NIO_Monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
+/* Internal C functions */
+static int NIO_Monitor_symbol2interest(VALUE interests);
+static void NIO_Monitor_update_interests(VALUE self, int interests);
 
-#if HAVE_RB_IO_T
-  rb_io_t *fptr;
-#else
-  OpenFile *fptr;
+/* Compatibility for Ruby <= 3.1 */
+#ifndef HAVE_RB_IO_DESCRIPTOR
+static int
+io_descriptor_fallback(VALUE io)
+{
+    rb_io_t *fptr;
+    GetOpenFile(io, fptr);
+    return fptr->fd;
+}
+#define rb_io_descriptor io_descriptor_fallback
 #endif
 
 /* Monitor control how a channel is being waited for by a monitor */
@@ -43,10 +54,14 @@ 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, "interests=", NIO_Monitor_set_interests, 1);
+    rb_define_method(cNIO_Monitor, "add_interest", NIO_Monitor_add_interest, 1);
+    rb_define_method(cNIO_Monitor, "remove_interest", NIO_Monitor_remove_interest, 1);
+    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);
@@ -55,78 +70,103 @@ void Init_NIO_Monitor()
     rb_define_method(cNIO_Monitor, "writeable?", NIO_Monitor_is_writable, 0);
 }
 
+static const rb_data_type_t NIO_Monitor_type = {
+    "NIO::Monitor",
+    {
+        NIO_Monitor_mark,
+        RUBY_TYPED_DEFAULT_FREE,
+        NIO_Monitor_memsize,
+    },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
 static VALUE NIO_Monitor_allocate(VALUE klass)
 {
     struct NIO_Monitor *monitor = (struct NIO_Monitor *)xmalloc(sizeof(struct NIO_Monitor));
-
-    return Data_Wrap_Struct(klass, NIO_Monitor_mark, NIO_Monitor_free, monitor);
+    assert(monitor);
+    *monitor = (struct NIO_Monitor){.self = Qnil};
+    return TypedData_Wrap_Struct(klass, &NIO_Monitor_type, monitor);
 }
 
-static void NIO_Monitor_mark(struct NIO_Monitor *monitor)
+static void NIO_Monitor_mark(void *data)
 {
+    struct NIO_Monitor *monitor = (struct NIO_Monitor *)data;
+    rb_gc_mark(monitor->self);
 }
 
-static void NIO_Monitor_free(struct NIO_Monitor *monitor)
+static size_t NIO_Monitor_memsize(const void *data)
 {
-    xfree(monitor);
+    const struct NIO_Monitor *monitor = (const struct NIO_Monitor *)data;
+    return sizeof(*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;
     ID interests_id;
 
-    #if HAVE_RB_IO_T
-        rb_io_t *fptr;
-    #else
-        OpenFile *fptr;
-    #endif
-
     interests_id = SYM2ID(interests);
 
-    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
 
-    if(interests_id == rb_intern("r")) {
+    if (interests_id == rb_intern("r")) {
         monitor->interests = EV_READ;
-    } else if(interests_id == rb_intern("w")) {
+    } else if (interests_id == rb_intern("w")) {
         monitor->interests = EV_WRITE;
-    } else if(interests_id == rb_intern("rw")) {
+    } else if (interests_id == rb_intern("rw")) {
         monitor->interests = EV_READ | EV_WRITE;
     } else {
-        rb_raise(rb_eArgError, "invalid event type %s (must be :r, :w, or :rw)",
-            RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0, 0)));
+        rb_raise(rb_eArgError, "invalid event type %s (must be :r, :w, or :rw)", RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0)));
     }
 
-    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);
+    int descriptor = rb_io_descriptor(rb_convert_type(io, T_FILE, "IO", "to_io"));
+    ev_io_init(&monitor->ev_io, NIO_Selector_monitor_callback, descriptor, 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);
+    selector = NIO_Selector_unwrap(selector_obj);
 
-    monitor->self = self;
+    RB_OBJ_WRITE(self, &monitor->self, self);
     monitor->ev_io.data = (void *)monitor;
 
     /* We can safely hang onto this as we also hang onto a reference to the
        object where it originally came from */
     monitor->selector = selector;
 
-    ev_io_start(selector->ev_loop, &monitor->ev_io);
+    if (monitor->interests) {
+        ev_io_start(selector->ev_loop, &monitor->ev_io);
+    }
 
     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);
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    rb_scan_args(argc, argv, "01", &deregister);
+    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 (monitor->interests && monitor->selector->ev_loop) {
+            ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
+        }
 
-    if(monitor->selector) {
-        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;
@@ -135,9 +175,9 @@ static VALUE NIO_Monitor_close(VALUE self)
 static VALUE NIO_Monitor_is_closed(VALUE self)
 {
     struct NIO_Monitor *monitor;
-    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
 
-    return !monitor->selector;
+    return monitor->selector == 0 ? Qtrue : Qfalse;
 }
 
 static VALUE NIO_Monitor_io(VALUE self)
@@ -150,6 +190,44 @@ static VALUE NIO_Monitor_interests(VALUE self)
     return rb_ivar_get(self, rb_intern("interests"));
 }
 
+static VALUE NIO_Monitor_set_interests(VALUE self, VALUE interests)
+{
+    if (NIL_P(interests)) {
+        NIO_Monitor_update_interests(self, 0);
+    } else {
+        NIO_Monitor_update_interests(self, NIO_Monitor_symbol2interest(interests));
+    }
+
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
+static VALUE NIO_Monitor_add_interest(VALUE self, VALUE interest)
+{
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    interest = monitor->interests | NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, (int)interest);
+
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
+static VALUE NIO_Monitor_remove_interest(VALUE self, VALUE interest)
+{
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    interest = monitor->interests & ~NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, (int)interest);
+
+    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"));
@@ -163,13 +241,13 @@ static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj)
 static VALUE NIO_Monitor_readiness(VALUE self)
 {
     struct NIO_Monitor *monitor;
-    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
 
-    if((monitor->revents & (EV_READ | EV_WRITE)) == (EV_READ | EV_WRITE)) {
+    if ((monitor->revents & (EV_READ | EV_WRITE)) == (EV_READ | EV_WRITE)) {
         return ID2SYM(rb_intern("rw"));
-    } else if(monitor->revents & EV_READ) {
+    } else if (monitor->revents & EV_READ) {
         return ID2SYM(rb_intern("r"));
-    } else if(monitor->revents & EV_WRITE) {
+    } else if (monitor->revents & EV_WRITE) {
         return ID2SYM(rb_intern("w"));
     } else {
         return Qnil;
@@ -179,9 +257,9 @@ static VALUE NIO_Monitor_readiness(VALUE self)
 static VALUE NIO_Monitor_is_readable(VALUE self)
 {
     struct NIO_Monitor *monitor;
-    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
 
-    if(monitor->revents & EV_READ) {
+    if (monitor->revents & EV_READ) {
         return Qtrue;
     } else {
         return Qfalse;
@@ -191,22 +269,76 @@ static VALUE NIO_Monitor_is_readable(VALUE self)
 static VALUE NIO_Monitor_is_writable(VALUE self)
 {
     struct NIO_Monitor *monitor;
-    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
 
-    if(monitor->revents & EV_WRITE) {
+    if (monitor->revents & EV_WRITE) {
         return Qtrue;
     } else {
         return Qfalse;
     }
 }
 
-/* libev callback fired whenever this monitor gets events */
-static void NIO_Monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
+/* Internal C functions */
+
+static int NIO_Monitor_symbol2interest(VALUE interests)
+{
+    ID interests_id;
+    interests_id = SYM2ID(interests);
+
+    if (interests_id == rb_intern("r")) {
+        return EV_READ;
+    } else if (interests_id == rb_intern("w")) {
+        return EV_WRITE;
+    } else if (interests_id == rb_intern("rw")) {
+        return 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)));
+    }
+}
+
+static void NIO_Monitor_update_interests(VALUE self, int interests)
 {
-    struct NIO_Monitor *monitor = (struct NIO_Monitor *)io->data;
+    ID interests_id;
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
 
-    assert(monitor->selector != 0);
-    monitor->revents = revents;
+    if (NIO_Monitor_is_closed(self) == Qtrue) {
+        rb_raise(rb_eEOFError, "monitor is closed");
+    }
 
-    NIO_Selector_handle_event(monitor->selector, monitor->self, revents);
+    if (interests) {
+        switch (interests) {
+            case EV_READ:
+                interests_id = rb_intern("r");
+                break;
+            case EV_WRITE:
+                interests_id = rb_intern("w");
+                break;
+            case EV_READ | EV_WRITE:
+                interests_id = rb_intern("rw");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "bogus NIO_Monitor_update_interests! (%d)", interests);
+        }
+
+        rb_ivar_set(self, rb_intern("interests"), ID2SYM(interests_id));
+    } else {
+        rb_ivar_set(self, rb_intern("interests"), Qnil);
+    }
+
+    if (monitor->interests != interests) {
+        // If the monitor currently has interests, we should stop it.
+        if (monitor->interests) {
+            ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
+        }
+
+        // Assign the interests we are now monitoring for:
+        monitor->interests = interests;
+        ev_io_set(&monitor->ev_io, monitor->ev_io.fd, monitor->interests);
+
+        // If we are interested in events, schedule the monitor back into the event loop:
+        if (monitor->interests) {
+            ev_io_start(monitor->selector->ev_loop, &monitor->ev_io);
+        }
+    }
 }

data/ext/nio4r/nio4r.h

@@ -6,49 +6,43 @@
 #ifndef NIO4R_H
 #define NIO4R_H
 
-#include "ruby.h"
-#include "rubyio.h"
 #include "libev.h"
+#include "ruby.h"
+#include "ruby/io.h"
 
-struct NIO_Selector
-{
+struct NIO_Selector {
     struct ev_loop *ev_loop;
     struct ev_timer timer; /* for timeouts */
-    struct ev_async wakeup;
+    struct ev_io wakeup;
 
-    int closed, selecting;
     int ready_count;
-    int ready_buffer_size;
-    VALUE *ready_buffer;
+    int closed, selecting;
+    int wakeup_reader, wakeup_writer;
+    volatile int wakeup_fired;
+
+    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;
 };
 
-#ifdef GetReadFile
-# define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
-#else
-
-#if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
-# define FPTR_TO_FD(fptr) fileno(fptr->f)
-#else
-# define FPTR_TO_FD(fptr) fptr->fd
-#endif /* !HAVE_RB_IO_T */
+struct NIO_ByteBuffer {
+    char *buffer;
+    int position, limit, capacity, mark;
+};
 
-#endif /* GetReadFile */
+struct NIO_Selector *NIO_Selector_unwrap(VALUE selector);
 
 /* Thunk between libev callbacks in NIO::Monitors and NIO::Selectors */
-void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents);
+void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
 
 #endif /* NIO4R_H */

data/ext/nio4r/nio4r_ext.c

@@ -1,16 +1,24 @@
 /*
- * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
- * LICENSE.txt for further details.
+ * Copyright (c) 2011-2017 Tony Arcieri. Distributed under the MIT License.
+ * See LICENSE.txt for further details.
  */
 
-#include "nio4r.h"
 #include "../libev/ev.c"
+#include "nio4r.h"
 
 void Init_NIO_Selector();
 void Init_NIO_Monitor();
+void Init_NIO_ByteBuffer();
 
 void Init_nio4r_ext()
 {
+    #ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+    #endif
+
+    ev_set_allocator(xrealloc);
+
     Init_NIO_Selector();
     Init_NIO_Monitor();
+    Init_NIO_ByteBuffer();
 }