cool.io 1.2.3-x86-mingw32 → 1.4.1-x86-mingw32

data/ext/libev/ev.h

@@ -1,7 +1,7 @@
 /*
  * libev native API header
  *
- * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2012,2015 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -42,12 +42,16 @@
 
 #ifdef __cplusplus
 # define EV_CPP(x) x
+# if __cplusplus >= 201103L
+#  define EV_THROW noexcept
+# else
+#  define EV_THROW throw ()
+# endif
 #else
 # define EV_CPP(x)
+# define EV_THROW
 #endif
 
-#define EV_THROW EV_CPP(throw())
-
 EV_CPP(extern "C" {)
 
 /*****************************************************************************/
@@ -148,6 +152,8 @@ EV_CPP(extern "C" {)
 
 typedef double ev_tstamp;
 
+#include <string.h> /* for memmove */
+
 #ifndef EV_ATOMIC_T
 # include <signal.h>
 # define EV_ATOMIC_T sig_atomic_t volatile
@@ -205,7 +211,7 @@ struct ev_loop;
 /*****************************************************************************/
 
 #define EV_VERSION_MAJOR 4
-#define EV_VERSION_MINOR 15
+#define EV_VERSION_MINOR 20
 
 /* eventmask, revents, events... */
 enum {
@@ -658,8 +664,10 @@ EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_T
 /* advanced stuff for threading etc. support, see docs */
 EV_API_DECL void ev_set_userdata (EV_P_ void *data) EV_THROW;
 EV_API_DECL void *ev_userdata (EV_P) EV_THROW;
-EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW;
-EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P) EV_THROW) EV_THROW;
+typedef void (*ev_loop_callback)(EV_P);
+EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW;
+/* C++ doesn't allow the use of the ev_loop_callback typedef here, so we need to spell it out */
+EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW;
 
 EV_API_DECL unsigned int ev_pending_count (EV_P) EV_THROW; /* number of pending events, if any */
 EV_API_DECL void ev_invoke_pending (EV_P); /* invoke all pending watchers */
@@ -713,7 +721,8 @@ EV_API_DECL void ev_resume  (EV_P) EV_THROW;
 #define ev_is_pending(ev)                    (0 + ((ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
 #define ev_is_active(ev)                     (0 + ((ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */
 
-#define ev_cb(ev)                            (ev)->cb /* rw */
+#define ev_cb_(ev)                           (ev)->cb /* rw */
+#define ev_cb(ev)                            (memmove (&ev_cb_ (ev), &((ev_watcher *)(ev))->cb, sizeof (ev_cb_ (ev))), (ev)->cb)
 
 #if EV_MINPRI == EV_MAXPRI
 # define ev_priority(ev)                     ((ev), EV_MINPRI)
@@ -726,11 +735,11 @@ EV_API_DECL void ev_resume  (EV_P) EV_THROW;
 #define ev_periodic_at(ev)                   (+((ev_watcher_time *)(ev))->at)
 
 #ifndef ev_set_cb
-# define ev_set_cb(ev,cb_)                   ev_cb (ev) = (cb_)
+# define ev_set_cb(ev,cb_)                   (ev_cb_ (ev) = (cb_), memmove (&((ev_watcher *)(ev))->cb, &ev_cb_ (ev), sizeof (ev_cb_ (ev))))
 #endif
 
 /* stopping (enabling, adding) a watcher does nothing if it is already running */
-/* stopping (disabling, deleting) a watcher does nothing unless its already running */
+/* stopping (disabling, deleting) a watcher does nothing unless it's already running */
 #if EV_PROTOTYPES
 
 /* feeds an event into a watcher as if the event actually occurred */
@@ -842,4 +851,3 @@ EV_API_DECL void ev_async_send     (EV_P_ ev_async *w) EV_THROW;
 EV_CPP(})
 
 #endif
-

data/ext/libev/ev_epoll.c

@@ -228,7 +228,10 @@ epoll_poll (EV_P_ ev_tstamp timeout)
       if (anfds [fd].emask & EV_EMASK_EPERM && events)
         fd_event (EV_A_ fd, events);
       else
-        epoll_eperms [i] = epoll_eperms [--epoll_epermcnt];
+        {
+          epoll_eperms [i] = epoll_eperms [--epoll_epermcnt];
+          anfds [fd].emask = 0;
+        }
     }
 }
 

data/ext/libev/ev_kqueue.c

@@ -1,7 +1,7 @@
 /*
  * libev kqueue backend
  *
- * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-

data/ext/libev/ev_select.c

@@ -106,6 +106,7 @@ if (__i == ((fd_set *)(set))->fd_count) {\
 } 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
@@ -183,8 +184,6 @@ select_modify (EV_P_ int fd, int oev, int nev)
   }
 }
 
-#undef socket
-
 static void
 select_poll (EV_P_ ev_tstamp timeout)
 {
@@ -246,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);
             }
 
           return;

data/ext/libev/ev_vars.h

@@ -1,7 +1,7 @@
 /*
  * loop member variable declarations
  *
- * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -194,9 +194,10 @@ VARx(unsigned int, loop_count) /* total number of loop iterations/blocks */
 VARx(unsigned int, loop_depth) /* #ev_run enters - #ev_run leaves */
 
 VARx(void *, userdata)
+/* C++ doesn't support the ev_loop_callback typedef here. stinks. */
 VAR (release_cb, void (*release_cb)(EV_P) EV_THROW)
 VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_THROW)
-VAR (invoke_cb , void (*invoke_cb) (EV_P))
+VAR (invoke_cb , ev_loop_callback invoke_cb)
 #endif
 
 #undef VARx

data/ext/libev/ev_win32.c

@@ -143,7 +143,7 @@ fail:
 
 #undef pipe
 #define pipe(filedes) ev_pipe (filedes)
-  
+
 #define EV_HAVE_EV_TIME 1
 ev_tstamp
 ev_time (void)

data/ext/libev/win_select.patch

@@ -0,0 +1,115 @@
+diff --git a/ext/libev/ev_select.c b/ext/libev/ev_select.c
+index f38d6ca..3a32642 100644
+--- a/ext/libev/ev_select.c
++++ b/ext/libev/ev_select.c
+@@ -67,6 +67,53 @@
+ 
+ #include <string.h>
+ 
++#ifdef _WIN32
++/*
++########## COOLIO PATCHERY HO! ##########
++
++Ruby undefs FD_* utilities for own implementation.
++It converts fd argument into socket handle internally on Windows,
++so libev should not use Ruby's FD_* utilities.
++
++Following FD_* utilities come from MinGW.
++RubyInstaller is built by MinGW so this should work.
++*/
++int PASCAL __WSAFDIsSet(SOCKET,fd_set*);
++#define EV_WIN_FD_CLR(fd,set) do { u_int __i;\
++for (__i = 0; __i < ((fd_set *)(set))->fd_count ; __i++) {\
++	if (((fd_set *)(set))->fd_array[__i] == (fd)) {\
++	while (__i < ((fd_set *)(set))->fd_count-1) {\
++		((fd_set*)(set))->fd_array[__i] = ((fd_set*)(set))->fd_array[__i+1];\
++		__i++;\
++	}\
++	((fd_set*)(set))->fd_count--;\
++	break;\
++	}\
++}\
++} while (0)
++#define EV_WIN_FD_SET(fd, set) do { u_int __i;\
++for (__i = 0; __i < ((fd_set *)(set))->fd_count ; __i++) {\
++	if (((fd_set *)(set))->fd_array[__i] == (fd)) {\
++		break;\
++	}\
++}\
++if (__i == ((fd_set *)(set))->fd_count) {\
++	if (((fd_set *)(set))->fd_count < FD_SETSIZE) {\
++		((fd_set *)(set))->fd_array[__i] = (fd);\
++		((fd_set *)(set))->fd_count++;\
++	}\
++}\
++} 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))
++/* ######################################## */
++#else
++#define EV_WIN_FD_CLR FD_CLR
++#define EV_WIN_FD_SET FD_SET
++#define EV_WIN_FD_ZERO FD_ZERO
++#define EV_WIN_FD_ISSET FD_ISSET
++#endif
++
+ 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)
+     if ((oev ^ nev) & EV_READ)
+     #endif
+       if (nev & EV_READ)
+-        FD_SET (handle, (fd_set *)vec_ri);
++        EV_WIN_FD_SET (handle, (fd_set *)vec_ri);
+       else
+-        FD_CLR (handle, (fd_set *)vec_ri);
++        EV_WIN_FD_CLR (handle, (fd_set *)vec_ri);
+ 
+     #if EV_SELECT_IS_WINSOCKET
+     if ((oev ^ nev) & EV_WRITE)
+     #endif
+       if (nev & EV_WRITE)
+-        FD_SET (handle, (fd_set *)vec_wi);
++        EV_WIN_FD_SET (handle, (fd_set *)vec_wi);
+       else
+-        FD_CLR (handle, (fd_set *)vec_wi);
++        EV_WIN_FD_CLR (handle, (fd_set *)vec_wi);
+ 
+ #else
+ 
+@@ -136,6 +183,8 @@ select_modify (EV_P_ int fd, int oev, int nev)
+   }
+ }
+ 
++#undef socket
++
+ static void
+ select_poll (EV_P_ ev_tstamp timeout)
+ {
+@@ -230,10 +279,10 @@ select_poll (EV_P_ ev_tstamp timeout)
+           int handle = fd;
+           #endif
+ 
+-          if (FD_ISSET (handle, (fd_set *)vec_ro)) events |= EV_READ;
+-          if (FD_ISSET (handle, (fd_set *)vec_wo)) events |= EV_WRITE;
++          if (EV_WIN_FD_ISSET (handle, (fd_set *)vec_ro)) events |= EV_READ;
++          if (EV_WIN_FD_ISSET (handle, (fd_set *)vec_wo)) events |= EV_WRITE;
+           #ifdef _WIN32
+-          if (FD_ISSET (handle, (fd_set *)vec_eo)) events |= EV_WRITE;
++          if (EV_WIN_FD_ISSET (handle, (fd_set *)vec_eo)) events |= EV_WRITE;
+           #endif
+ 
+           if (expect_true (events))
+@@ -279,9 +328,9 @@ select_init (EV_P_ int flags)
+   backend_poll    = select_poll;
+ 
+ #if EV_SELECT_USE_FD_SET
+-  vec_ri  = ev_malloc (sizeof (fd_set)); FD_ZERO ((fd_set *)vec_ri);
++  vec_ri  = ev_malloc (sizeof (fd_set)); EV_WIN_FD_ZERO ((fd_set *)vec_ri);
+   vec_ro  = ev_malloc (sizeof (fd_set));
+-  vec_wi  = ev_malloc (sizeof (fd_set)); FD_ZERO ((fd_set *)vec_wi);
++  vec_wi  = ev_malloc (sizeof (fd_set)); EV_WIN_FD_ZERO ((fd_set *)vec_wi);
+   vec_wo  = ev_malloc (sizeof (fd_set));
+   #ifdef _WIN32
+   vec_eo  = ev_malloc (sizeof (fd_set));

data/lib/cool.io.rb

@@ -19,14 +19,16 @@ require "cool.io/listener"
 require "cool.io/dns_resolver"
 require "cool.io/socket"
 require "cool.io/server"
-require "cool.io/http_client"
-require "cool.io/dsl"
 
 module Coolio
-  def self.inspect; "Cool.io"; end
+  def self.inspect
+    "Cool.io"
+  end
 end
 
 module Cool
   # Allow Coolio module to be referenced as Cool.io
-  def self.io; Coolio; end
+  def self.io
+    Coolio
+  end
 end

data/lib/cool.io/dns_resolver.rb

@@ -17,6 +17,8 @@
 #
 #++
 
+require 'resolv'
+
 module Coolio
   # A non-blocking DNS resolver.  It provides interfaces for querying both
   # /etc/hosts and nameserves listed in /etc/resolv.conf, or nameservers of
@@ -31,12 +33,6 @@ module Coolio
   # again.
   class DNSResolver < IOWatcher
     #--
-    # TODO check if it's caching right
-    if RUBY_PLATFORM =~ /mingw|win32/
-      HOSTS = 'c:\WINDOWS\system32\drivers\etc\hosts'
-    else
-      HOSTS = '/etc/hosts'
-    end
     DNS_PORT = 53
     DATAGRAM_SIZE = 512
     TIMEOUT = 3 # Retry timeout for each datagram sent
@@ -44,7 +40,7 @@ module Coolio
     # so currently total is 12s before it will err due to timeouts
     # if it errs due to inability to reach the DNS server [Errno::EHOSTUNREACH], same
     # Query /etc/hosts (or the specified hostfile) for the given host
-    def self.hosts(host, hostfile = HOSTS)
+    def self.hosts(host, hostfile = Resolv::Hosts::DefaultFileName)
       hosts = {}
       File.open(hostfile) do |f|
         f.each_line do |host_entry|
@@ -63,7 +59,6 @@ module Coolio
     # use nameservers listed in /etc/resolv.conf
     def initialize(hostname, *nameservers)
       if nameservers.empty?
-        require 'resolv'
         nameservers = Resolv::DNS::Config.default_config_hash[:nameserver]
         raise RuntimeError, "no nameservers found" if nameservers.empty? # TODO just call resolve_failed, not raise [also handle Errno::ENOENT)]
       end
@@ -111,9 +106,8 @@ module Coolio
     def send_request
       nameserver = @nameservers.shift
       @nameservers << nameserver # rotate them
-      @socket.connect @nameservers.first, DNS_PORT
       begin
-        @socket.send request_message, 0
+        @socket.send request_message, 0, @nameservers.first, DNS_PORT
       rescue Errno::EHOSTUNREACH # TODO figure out why it has to be wrapper here, when the other wrapper should be wrapping this one!
       end
     end

data/lib/cool.io/dsl.rb

@@ -124,11 +124,15 @@ end
 # The Cool module containing all our coolness
 module Cool
   module Coolness
-    def cool; Cool::IOThunk; end
+    def cool
+      Cool::IOThunk
+    end
   end
 
   module IOThunk
-    def self.io; Coolio::DSL; end
+    def self.io
+      Coolio::DSL
+    end
   end
 end
 

data/lib/cool.io/io.rb

@@ -31,25 +31,45 @@ module Coolio
     #
 
     # Attach to the event loop
-    def attach(loop); @_read_watcher.attach loop; schedule_write if !@_write_buffer.empty?; self; end
+    def attach(loop)
+      @_read_watcher.attach(loop)
+      schedule_write if !@_write_buffer.empty?
+      self
+    end
 
     # Detach from the event loop
-    def detach; @_read_watcher.detach; self; end # TODO should these detect write buffers, as well?
+    def detach
+      # TODO should these detect write buffers, as well?
+      @_read_watcher.detach
+      self
+    end
 
     # Enable the watcher
-    def enable; @_read_watcher.enable; self; end
+    def enable
+      @_read_watcher.enable
+      self
+    end
 
     # Disable the watcher
-    def disable; @_read_watcher.disable; self; end
+    def disable
+      @_read_watcher.disable
+      self
+    end
 
     # Is the watcher attached?
-    def attached?; @_read_watcher.attached?; end
+    def attached?
+      @_read_watcher.attached?
+    end
 
     # Is the watcher enabled?
-    def enabled?; @_read_watcher.enabled?; end
+    def enabled?
+      @_read_watcher.enabled?
+    end
 
     # Obtain the event loop associated with this object
-    def evloop; @_read_watcher.evloop; end
+    def evloop
+      @_read_watcher.evloop
+    end
 
     #
     # Callbacks for asynchronous events
@@ -78,16 +98,11 @@ module Coolio
       data.size
     end
 
-    # Number of bytes are currently in the output buffer
-    def output_buffer_size
-      @_write_buffer.size
-    end
-
     # Close the IO stream
     def close
       detach if attached?
       detach_write_watcher
-      @_io.close unless @_io.closed?
+      @_io.close unless closed?
 
       on_close
       nil
@@ -136,7 +151,7 @@ module Coolio
     # Schedule a write to be performed when the IO object becomes writable
     def schedule_write
       return unless @_io # this would mean 'we are still pre DNS here'
-      return unless attached? # this would mean 'currently unattached' -- ie still pre DNS, or just plain not attached, which is ok
+      return unless @_read_watcher.attached? # this would mean 'currently unattached' -- ie still pre DNS, or just plain not attached, which is ok
       begin
         enable_write_watcher
       rescue IOError
@@ -167,8 +182,13 @@ module Coolio
       end
 
       # Configure IOWatcher event callbacks to call the method passed to #initialize
-      def on_readable; @coolio_io.__send__(:on_readable); end
-      def on_writable; @coolio_io.__send__(:on_writable); end
+      def on_readable
+        @coolio_io.__send__(:on_readable)
+      end
+
+      def on_writable
+        @coolio_io.__send__(:on_writable)
+      end
     end
   end
 end