cool.io 1.4.5-x64-mingw32 → 1.7.1-x64-mingw32

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 24
 
 /* eventmask, revents, events... */
 enum {
@@ -515,10 +515,10 @@ enum {
 
 /* method bits to be ored together */
 enum {
-  EVBACKEND_SELECT  = 0x00000001U, /* about anywhere */
-  EVBACKEND_POLL    = 0x00000002U, /* !win */
+  EVBACKEND_SELECT  = 0x00000001U, /* available just about anywhere */
+  EVBACKEND_POLL    = 0x00000002U, /* !win, !aix, broken on osx */
   EVBACKEND_EPOLL   = 0x00000004U, /* linux */
-  EVBACKEND_KQUEUE  = 0x00000008U, /* bsd */
+  EVBACKEND_KQUEUE  = 0x00000008U, /* bsd, broken on osx */
   EVBACKEND_DEVPOLL = 0x00000010U, /* solaris 8 */ /* NYI */
   EVBACKEND_PORT    = 0x00000020U, /* solaris 10 */
   EVBACKEND_ALL     = 0x0000003FU, /* all known backends */
@@ -851,3 +851,4 @@ EV_API_DECL void ev_async_send     (EV_P_ ev_async *w) EV_THROW;
 EV_CPP(})
 
 #endif
+

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;
             }
         }
@@ -235,7 +235,8 @@ epoll_poll (EV_P_ ev_tstamp timeout)
     }
 }
 
-int inline_size
+inline_size
+int
 epoll_init (EV_P_ int flags)
 {
 #ifdef EPOLL_CLOEXEC
@@ -260,14 +261,16 @@ epoll_init (EV_P_ int flags)
   return EVBACKEND_EPOLL;
 }
 
-void inline_size
+inline_size
+void
 epoll_destroy (EV_P)
 {
   ev_free (epoll_events);
   array_free (epoll_eperm, EMPTY);
 }
 
-void inline_size
+inline_size
+void
 epoll_fork (EV_P)
 {
   close (backend_fd);

data/ext/libev/ev_kqueue.c

@@ -43,7 +43,8 @@
 #include <string.h>
 #include <errno.h>
 
-void inline_speed
+inline_speed
+void
 kqueue_change (EV_P_ int fd, int filter, int flags, int fflags)
 {
   ++kqueue_changecnt;
@@ -152,7 +153,8 @@ kqueue_poll (EV_P_ ev_tstamp timeout)
     }
 }
 
-int inline_size
+inline_size
+int
 kqueue_init (EV_P_ int flags)
 {
   /* initialize the kernel queue */
@@ -176,14 +178,16 @@ kqueue_init (EV_P_ int flags)
   return EVBACKEND_KQUEUE;
 }
 
-void inline_size
+inline_size
+void
 kqueue_destroy (EV_P)
 {
   ev_free (kqueue_events);
   ev_free (kqueue_changes);
 }
 
-void inline_size
+inline_size
+void
 kqueue_fork (EV_P)
 {
   /* some BSD kernels don't just destroy the kqueue itself,

data/ext/libev/ev_poll.c

@@ -39,7 +39,8 @@
 
 #include <poll.h>
 
-void inline_size
+inline_size
+void
 pollidx_init (int *base, int count)
 {
   /* consider using memset (.., -1, ...), which is practically guaranteed
@@ -126,7 +127,8 @@ poll_poll (EV_P_ ev_tstamp timeout)
       }
 }
 
-int inline_size
+inline_size
+int
 poll_init (EV_P_ int flags)
 {
   backend_mintime = 1e-3;
@@ -139,7 +141,8 @@ poll_init (EV_P_ int flags)
   return EVBACKEND_POLL;
 }
 
-void inline_size
+inline_size
+void
 poll_destroy (EV_P)
 {
   ev_free (pollidxs);

data/ext/libev/ev_port.c

@@ -55,7 +55,8 @@
 #include <string.h>
 #include <errno.h>
 
-void inline_speed
+inline_speed
+void
 port_associate_and_check (EV_P_ int fd, int ev)
 {
   if (0 >
@@ -136,7 +137,8 @@ port_poll (EV_P_ ev_tstamp timeout)
     }
 }
 
-int inline_size
+inline_size
+int
 port_init (EV_P_ int flags)
 {
   /* Initialize the kernel queue */
@@ -163,13 +165,15 @@ port_init (EV_P_ int flags)
   return EVBACKEND_PORT;
 }
 
-void inline_size
+inline_size
+void
 port_destroy (EV_P)
 {
   ev_free (port_events);
 }
 
-void inline_size
+inline_size
+void
 port_fork (EV_P)
 {
   close (backend_fd);

data/ext/libev/ev_select.c

@@ -319,7 +319,8 @@ select_poll (EV_P_ ev_tstamp timeout)
 #endif
 }
 
-int inline_size
+inline_size
+int
 select_init (EV_P_ int flags)
 {
   backend_mintime = 1e-6;
@@ -348,7 +349,8 @@ select_init (EV_P_ int flags)
   return EVBACKEND_SELECT;
 }
 
-void inline_size
+inline_size
+void
 select_destroy (EV_P)
 {
   ev_free (vec_ri);

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/lib/cool.io/dns_resolver.rb

@@ -49,6 +49,15 @@ module Coolio
           entries.each { |e| hosts[e] ||= addr }
         end
       end
+      if hosts.empty?
+        # On Windows, there is a case that hosts file doesn't have entry by default
+        # and preferred IPv4/IPv6 behavior may be changed by registry key [1], so
+        # "localhost" should be resolved by getaddrinfo.
+        # (first[3] means preferred resolved IP address ::1 or 127.0.0.1)
+        # [1] https://docs.microsoft.com/en-us/troubleshoot/windows-server/networking/configure-ipv6-in-windows
+        require "socket"
+        hosts["localhost"] = ::Socket.getaddrinfo("localhost", nil).first[3]
+      end
 
       hosts[host]
     end

data/lib/cool.io/socket.rb

@@ -137,6 +137,8 @@ module Coolio
 
     private :preinitialize
 
+    PEERADDR_FAILED = ["?", 0, "name resolusion failed", "?"]
+
     def initialize(socket)
       unless socket.is_a?(::TCPSocket) or socket.is_a?(TCPConnectSocket)
         raise TypeError, "socket must be a TCPSocket"
@@ -144,7 +146,7 @@ module Coolio
 
       super
 
-      @address_family, @remote_port, @remote_host, @remote_addr = socket.peeraddr
+      @address_family, @remote_port, @remote_host, @remote_addr = (socket.peeraddr rescue PEERADDR_FAILED)
     end
 
     def peeraddr

data/lib/cool.io/version.rb

@@ -1,5 +1,5 @@
 module Coolio
-  VERSION = "1.4.5"
+  VERSION = "1.7.1"
   
   def self.version
     VERSION

data/libev_ruby_gil.diff

@@ -0,0 +1,175 @@
+diff --git a/ext/libev/ev.c b/ext/libev/ev.c
+index 39b9faf..dae87f1 100644
+--- a/ext/libev/ev.c
++++ b/ext/libev/ev.c
+@@ -37,6 +37,10 @@
+  * either the BSD or the GPL.
+  */
+ 
++/* ########## COOLIO PATCHERY HO! ########## */
++#include "ruby.h"
++/* ######################################## */
++
+ /* this big block deduces configuration from config.h */
+ #ifndef EV_STANDALONE
+ # ifdef EV_CONFIG_H
+@@ -107,7 +111,7 @@
+ #  undef EV_USE_POLL
+ #  define EV_USE_POLL 0
+ # endif
+-   
++
+ # if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
+ #  ifndef EV_USE_EPOLL
+ #   define EV_USE_EPOLL EV_FEATURE_BACKENDS
+@@ -116,7 +120,7 @@
+ #  undef EV_USE_EPOLL
+ #  define EV_USE_EPOLL 0
+ # endif
+-   
++
+ # if HAVE_KQUEUE && HAVE_SYS_EVENT_H
+ #  ifndef EV_USE_KQUEUE
+ #   define EV_USE_KQUEUE EV_FEATURE_BACKENDS
+@@ -125,7 +129,7 @@
+ #  undef EV_USE_KQUEUE
+ #  define EV_USE_KQUEUE 0
+ # endif
+-   
++
+ # if HAVE_PORT_H && HAVE_PORT_CREATE
+ #  ifndef EV_USE_PORT
+ #   define EV_USE_PORT EV_FEATURE_BACKENDS
+@@ -161,7 +165,7 @@
+ #  undef EV_USE_EVENTFD
+ #  define EV_USE_EVENTFD 0
+ # endif
+- 
++
+ #endif
+ 
+ #include <stdlib.h>
+@@ -2174,7 +2178,7 @@ downheap (ANHE *heap, int N, int k)
+ 
+       heap [k] = heap [c];
+       ev_active (ANHE_w (heap [k])) = k;
+-      
++
+       k = c;
+     }
+ 
+@@ -2594,7 +2598,7 @@ ev_supported_backends (void) EV_THROW
+   if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
+   if (EV_USE_POLL  ) flags |= EVBACKEND_POLL;
+   if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
+-  
++
+   return flags;
+ }
+ 
+@@ -3398,9 +3402,33 @@ time_update (EV_P_ ev_tstamp max_block)
+     }
+ }
+ 
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
++struct ev_poll_args {
++  struct ev_loop *loop;
++  ev_tstamp waittime;
++};
++
++static
++VALUE ev_backend_poll(void *ptr)
++{
++  struct ev_poll_args *args = (struct ev_poll_args *)ptr;
++  struct ev_loop *loop = args->loop;
++  backend_poll (EV_A_ args->waittime);
++  return Qnil;
++}
++#endif
++/* ######################################## */
++
+ int
+ ev_run (EV_P_ int flags)
+ {
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
++    struct ev_poll_args poll_args;
++#endif
++/* ######################################## */
++
+ #if EV_FEATURE_API
+   ++loop_depth;
+ #endif
+@@ -3518,7 +3546,70 @@ ev_run (EV_P_ int flags)
+         ++loop_count;
+ #endif
+         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
+-        backend_poll (EV_A_ waittime);
++
++/*
++########################## COOLIO PATCHERY HO! ##########################
++
++According to the grandwizards of Ruby, locking and unlocking of the global
++interpreter lock are apparently too powerful a concept for a mere mortal to
++wield (although redefining what + and - do to numbers is totally cool).
++And so it came to pass that the only acceptable way to release the global
++interpreter lock is through a convoluted callback system that thakes a
++function pointer. While the grandwizard of libev foresaw this sort of scenario,
++he too attempted to place an API with callbacks on it, one that runs before
++the system call, and one that runs immediately after.
++
++And so it came to pass that trying to wrap everything up in callbacks created
++two incompatible APIs, Ruby's which releases the global interpreter lock and
++reacquires it when the callback returns, and libev's, which wants two
++callbacks, one which runs before the polling operation starts, and one which
++runs after it finishes.
++
++These two systems are incompatible as they both want to use callbacks to
++solve the same problem, however libev wants to use before/after callbacks,
++and Ruby wants to use an "around" callback. This presents a significant
++problem as these two patterns of callbacks are diametrical opposites of each
++other and thus cannot be composed.
++
++And thus we are left with no choice but to patch the internals of libev in
++order to release a mutex at just the precise moment.
++
++This is a great example of a situation where granular locking and unlocking
++of the GVL is practically required. The goal is to get as close to the
++system call as possible, and to keep the GVL unlocked for the shortest
++amount of time possible.
++
++Perhaps Ruby could benefit from such an API, e.g:
++
++rb_thread_unsafe_dangerous_crazy_blocking_region_begin(...);
++rb_thread_unsafe_dangerous_crazy_blocking_region_end(...);
++
++#######################################################################
++*/
++
++/*
++  simulate to rb_thread_call_without_gvl using rb_theread_blocking_region.
++  https://github.com/brianmario/mysql2/blob/master/ext/mysql2/client.h#L8
++*/
++
++#ifndef HAVE_RB_THREAD_CALL_WITHOUT_GVL
++#ifdef HAVE_RB_THREAD_BLOCKING_REGION
++#define rb_thread_call_without_gvl(func, data1, ubf, data2) \
++  rb_thread_blocking_region((rb_blocking_function_t *)func, data1, ubf, data2)
++#endif
++#endif
++
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
++        poll_args.loop = loop;
++        poll_args.waittime = waittime;
++        rb_thread_call_without_gvl(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
++#else
++         backend_poll (EV_A_ waittime);
++#endif
++/*
++############################# END PATCHERY ############################
++*/
++
+         assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
+ 
+         pipe_write_wanted = 0; /* just an optimisation, no fence needed */

data/{ext/libev/win_select.patch → libev_win_select.diff}

@@ -1,8 +1,20 @@
+diff --git a/ext/libev/ev.c b/ext/libev/ev.c
+index dae87f1..d15f6bd 100644
+--- a/ext/libev/ev.c
++++ b/ext/libev/ev.c
+@@ -207,6 +207,7 @@
+ #else
+ # include <io.h>
+ # define WIN32_LEAN_AND_MEAN
++# define FD_SETSIZE 1024
+ # include <winsock2.h>
+ # include <windows.h>
+ # ifndef EV_SELECT_IS_WINSOCKET
 diff --git a/ext/libev/ev_select.c b/ext/libev/ev_select.c
-index f38d6ca..3a32642 100644
+index f38d6ca..7050778 100644
 --- a/ext/libev/ev_select.c
 +++ b/ext/libev/ev_select.c
-@@ -67,6 +67,53 @@
+@@ -67,6 +67,54 @@
  
  #include <string.h>
  
@@ -45,6 +57,7 @@ index f38d6ca..3a32642 100644
 +} while(0)
 +#define EV_WIN_FD_ZERO(set) (((fd_set *)(set))->fd_count=0)
 +#define EV_WIN_FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set *)(set))
++#define EV_WIN_FD_COUNT(set) (((fd_set *)(set))->fd_count)
 +/* ######################################## */
 +#else
 +#define EV_WIN_FD_CLR FD_CLR
@@ -56,7 +69,7 @@ index f38d6ca..3a32642 100644
  static void
  select_modify (EV_P_ int fd, int oev, int nev)
  {
-@@ -91,17 +138,17 @@ select_modify (EV_P_ int fd, int oev, int nev)
+@@ -91,17 +139,17 @@ select_modify (EV_P_ int fd, int oev, int nev)
      if ((oev ^ nev) & EV_READ)
      #endif
        if (nev & EV_READ)
@@ -78,16 +91,18 @@ index f38d6ca..3a32642 100644
  
  #else
  
-@@ -136,6 +183,8 @@ select_modify (EV_P_ int fd, int oev, int nev)
-   }
- }
+@@ -197,8 +245,8 @@ select_poll (EV_P_ ev_tstamp timeout)
+         {
+           if (timeout)
+             {
+-              unsigned long ms = timeout * 1e3;
+-              Sleep (ms ? ms : 1);
++              unsigned long ms = (unsigned long)(timeout * 1e3);
++              SleepEx (ms ? ms : 1, TRUE);
+             }
  
-+#undef socket
-+
- static void
- select_poll (EV_P_ ev_tstamp timeout)
- {
-@@ -230,10 +279,10 @@ select_poll (EV_P_ ev_tstamp timeout)
+           return;
+@@ -230,10 +278,10 @@ select_poll (EV_P_ ev_tstamp timeout)
            int handle = fd;
            #endif
  
@@ -101,7 +116,7 @@ index f38d6ca..3a32642 100644
            #endif
  
            if (expect_true (events))
-@@ -279,9 +328,9 @@ select_init (EV_P_ int flags)
+@@ -279,9 +327,9 @@ select_init (EV_P_ int flags)
    backend_poll    = select_poll;
  
  #if EV_SELECT_USE_FD_SET