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

data/.travis.yml

@@ -1,4 +1,13 @@
+language: ruby
+
 rvm:
-  - 1.8.7
-  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+  - ruby-head
   - rbx
+
+matrix:
+  allow_failures:
+    - rvm: rbx

data/CHANGES.md

@@ -1,9 +1,27 @@
+1.2.3
+-----
+
+* Fix CPU consuming issue on Windows.
+
+1.2.2
+-----
+
+* Add timeout option to Loop#run and Loop#run_once. Default by nil
+* Support Ruby 2.2.0
+
+1.2.1
+-----
+
+* Release the GIL when libev polls (#24)
+* Add Listener#listen method to change backlog size
+
 1.2.0
 -----
 
 * Support Windows environment via cross compilation
 * Include iobuffer library
 * Update to libev 4.15
+* Remove Ruby 1.8 support
 
 1.1.0
 -----

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in cool.io.gemspec
 gemspec

data/README.md

@@ -1,8 +1,7 @@
 Cool.io
 =======
 
-### NOTE: cool.io is in maintenance mode only and is not being actively developed
-### Please check out [Celluloid::IO](http://github.com/celluloid/celluloid-io) instead!
+### If you are interested in Celluloid based IO framework, please check out [Celluloid::IO](http://github.com/celluloid/celluloid-io)
 
 Cool.io is an event library for Ruby, built on the libev event library which 
 provides a cross-platform interface to high performance system calls .  This 
@@ -15,10 +14,8 @@ applications.
 
 You can include Cool.io in your programs with:
 
-	require 'rubygems'
 	require 'cool.io'
 
-Questions? Sign up for the mailing list by emailing: [cool.io@librelist.com](mailto:cool.io@librelist.com)
 
 Anatomy
 -------
@@ -97,7 +94,6 @@ Example Program
 
 Cool.io provides a Sinatra-like DSL for authoring event-driven programs:
 
-    require 'rubygems'
     require 'cool.io'
 
     ADDR = '127.0.0.1'

data/ext/cool.io/cool.io.h

@@ -32,6 +32,7 @@ struct Coolio_Event
 struct Coolio_Loop 
 {
   struct ev_loop *ev_loop;
+  struct ev_timer timer; /* for timeouts */
 
   int running;
   int events_received;

data/ext/cool.io/ev_wrap.h

@@ -1,7 +1,9 @@
 #define EV_STANDALONE              /* keeps ev from requiring config.h */
+
 #ifdef _WIN32
-# define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
-# define FD_SETSIZE 2048 /* wishful thinking, as msvcrt6 [?] seems to only allow 512 fd's and 256 sockets max */
+#define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
+#define EV_USE_MONOTONIC 0
+#define EV_USE_REALTIME 0
 #endif
 
 #include "../libev/ev.h"

data/ext/cool.io/extconf.rb

@@ -8,6 +8,10 @@ if have_func('rb_thread_blocking_region')
   $defs << '-DHAVE_RB_THREAD_BLOCKING_REGION'
 end
 
+if have_func('rb_thread_call_without_gvl')
+  $defs << '-DHAVE_RB_THEREAD_CALL_WITHOUT_GVL'
+end
+
 if have_func('rb_thread_alone')
   $defs << '-DHAVE_RB_THREAD_ALONE'
 end

data/ext/cool.io/loop.c

@@ -11,14 +11,6 @@
 
 #include "cool.io.h"
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
-#  define Coolio_Loop_may_block_safely() (1)
-#elif defined(HAVE_RB_THREAD_ALONE)
-#  define Coolio_Loop_may_block_safely() (rb_thread_alone())
-#else /* just in case Ruby changes: */
-#  define Coolio_Loop_may_block_safely() (0)
-#endif
-
 static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Loop = Qnil;
 
@@ -28,10 +20,10 @@ static void Coolio_Loop_free(struct Coolio_Loop *loop);
 
 static VALUE Coolio_Loop_initialize(VALUE self);
 static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags);
-static VALUE Coolio_Loop_run_once(VALUE self);
+static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self);
 static VALUE Coolio_Loop_run_nonblock(VALUE self);
 
-static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data);
+static void Coolio_Loop_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
 static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data);
 
 #define DEFAULT_EVENTBUF_SIZE 32
@@ -54,7 +46,7 @@ void Init_coolio_loop()
  
   rb_define_method(cCoolio_Loop, "initialize", Coolio_Loop_initialize, 0);
   rb_define_private_method(cCoolio_Loop, "ev_loop_new", Coolio_Loop_ev_loop_new, 1);
-  rb_define_method(cCoolio_Loop, "run_once", Coolio_Loop_run_once, 0);
+  rb_define_method(cCoolio_Loop, "run_once", Coolio_Loop_run_once, -1);
   rb_define_method(cCoolio_Loop, "run_nonblock", Coolio_Loop_run_nonblock, 0);
 }
 
@@ -63,6 +55,7 @@ static VALUE Coolio_Loop_allocate(VALUE klass)
   struct Coolio_Loop *loop = (struct Coolio_Loop *)xmalloc(sizeof(struct Coolio_Loop));
 
   loop->ev_loop = 0;
+  ev_init(&loop->timer, Coolio_Loop_timeout_callback);
   loop->running = 0;
   loop->events_received = 0;
   loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE;
@@ -174,90 +167,57 @@ void Coolio_Loop_process_event(VALUE watcher, int revents)
   loop_data->events_received++;
 }
 
+/* Called whenever a timeout fires on the event loop */
+static void Coolio_Loop_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
+{
+  /* We don't actually need to do anything here, the mere firing of the
+     timer is sufficient to interrupt the selector. However, libev still wants a callback */
+}
+
 /**
  *  call-seq:
  *    Coolio::Loop.run_once -> nil
  * 
  * Run the Coolio::Loop once, blocking until events are received.
  */
-static VALUE Coolio_Loop_run_once(VALUE self)
+static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self)
 {
+  VALUE timeout;
   VALUE nevents;
+  struct Coolio_Loop *loop_data;
 
-  if (Coolio_Loop_may_block_safely()) {
-    struct Coolio_Loop *loop_data;
-
-    Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  rb_scan_args(argc, argv, "01", &timeout);
 
-    assert(loop_data->ev_loop && !loop_data->events_received);
+  if (timeout != Qnil && NUM2DBL(timeout) < 0) {
+    rb_raise(rb_eArgError, "time interval must be positive");
+  }
 
-    Coolio_Loop_ev_loop_oneshot(loop_data);
-    Coolio_Loop_dispatch_events(loop_data);
+  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
 
-    nevents = INT2NUM(loop_data->events_received);
-    loop_data->events_received = 0;
+  assert(loop_data->ev_loop && !loop_data->events_received);
 
+  /* Implement the optional timeout (if any) as a ev_timer */
+  /* Using the technique written at
+     http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#code_ev_timer_code_relative_and_opti,
+     the timer is not stopped/started everytime when timeout is specified, instead,
+     the timer is stopped when timeout is not specified. */
+  if (timeout != Qnil) {
+    /* It seems libev is not a fan of timers being zero, so fudge a little */
+    loop_data->timer.repeat = NUM2DBL(timeout) + 0.0001;
+    ev_timer_again(loop_data->ev_loop, &loop_data->timer);
   } else {
-    nevents = Coolio_Loop_run_nonblock(self);
-    rb_thread_schedule();
+    ev_timer_stop(loop_data->ev_loop, &loop_data->timer);
   }
 
-  return nevents;
-}
-
-/* Ruby 1.9 supports blocking system calls through rb_thread_blocking_region() */
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
-#define HAVE_EV_LOOP_ONESHOT
-static VALUE Coolio_Loop_ev_loop_oneshot_blocking(void *ptr) 
-{
-  /* The libev loop has now escaped through the Global VM Lock unscathed! */
-  struct Coolio_Loop *loop_data = (struct Coolio_Loop *)ptr;
-
+  /* libev is patched to release the GIL when it makes its system call */
   RUN_LOOP(loop_data, EVLOOP_ONESHOT);
-  
-  return Qnil;
-}
 
-static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
-{
-  /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
-  rb_thread_blocking_region(Coolio_Loop_ev_loop_oneshot_blocking, loop_data, RUBY_UBF_IO, 0);
-}
-#endif
-
-/* Ruby 1.8 requires us to periodically run the event loop then defer back to
- * the green threads scheduler */
-#ifndef HAVE_EV_LOOP_ONESHOT
-#define BLOCKING_INTERVAL 0.01 /* Block for 10ms at a time */
-
-/* Stub for scheduler's ev_timer callback */
-static void timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
-{
-   ev_timer_again (ev_loop, timer);
-}
-
-/* Run the event loop, calling rb_thread_schedule every 10ms */
-static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
-{
-  struct ev_timer timer;
-  struct timeval tv;
-
-  /* Set up an ev_timer to unblock the loop every 10ms */
-  ev_timer_init(&timer, timer_callback, BLOCKING_INTERVAL, BLOCKING_INTERVAL);
-  ev_timer_start(loop_data->ev_loop, &timer);
-
-  /* Loop until we receive events */
-  while(!loop_data->events_received) {
-    TRAP_BEG;
-    RUN_LOOP(loop_data, EVLOOP_ONESHOT);
-    TRAP_END;
-
-    rb_thread_schedule();
-  }
+  Coolio_Loop_dispatch_events(loop_data);
+  nevents = INT2NUM(loop_data->events_received);
+  loop_data->events_received = 0;
 
-  ev_timer_stop(loop_data->ev_loop, &timer);
+  return nevents;
 }
-#endif
 
 /**
  *  call-seq:

data/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
@@ -3237,9 +3241,27 @@ 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)
+static
+VALUE ev_backend_poll(void **args)
+{
+  struct ev_loop *loop = (struct ev_loop *)args[0];
+  ev_tstamp waittime = *(ev_tstamp *)args[1];
+  backend_poll (EV_A_ waittime);
+}
+#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)
+    void *poll_args[2];
+#endif
+/* ######################################## */
+
 #if EV_FEATURE_API
   ++loop_depth;
 #endif
@@ -3357,7 +3379,67 @@ ev_run (EV_P_ int flags)
         ++loop_count;
 #endif
         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
+
+/*
+########################## COOLIO PATCHERY HO! ##########################
+
+The original patch file is made by Tony Arcieri.
+https://github.com/celluloid/nio4r/blob/680143345726c5a64bb22376ca8fc3c6857019ae/ext/libev/ruby_gil.patch.
+
+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.
+
+Let this be a lesson to the all: CALLBACKS FUCKING BLOW
+
+#######################################################################
+*/
+
+/*
+  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[0] = (void *)loop;
+        poll_args[1] = (void *)&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/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/ext/libev/ruby_gil.patch

@@ -0,0 +1,97 @@
+diff --git a/ext/libev/ev.c b/ext/libev/ev.c
+index e5bd5ab..10f6ff2 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
+@@ -3237,9 +3241,27 @@ time_update (EV_P_ ev_tstamp max_block)
+     }
+ }
+ 
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++static
++VALUE ev_backend_poll(void **args)
++{
++  struct ev_loop *loop = (struct ev_loop *)args[0];
++  ev_tstamp waittime = *(ev_tstamp *)args[1];
++  backend_poll (EV_A_ waittime);
++}
++#endif
++/* ######################################## */
++
+ int
+ ev_run (EV_P_ int flags)
+ {
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++    void *poll_args[2];
++#endif
++/* ######################################## */
++
+ #if EV_FEATURE_API
+   ++loop_depth;
+ #endif
+@@ -3357,7 +3379,53 @@ ev_run (EV_P_ int flags)
+         ++loop_count;
+ #endif
+         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
++
++/*
++########################## COOLIO PATCHERY HO! ##########################
++
++The original patch file is made by Tony Arcieri.
++https://github.com/celluloid/nio4r/blob/680143345726c5a64bb22376ca8fc3c6857019ae/ext/libev/ruby_gil.patch.
++
++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.
++
++Let this be a lesson to the all: CALLBACKS FUCKING BLOW
++
++#######################################################################
++*/
++
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++        poll_args[0] = (void *)loop;
++        poll_args[1] = (void *)&waittime;
++        rb_thread_blocking_region(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/lib/cool.io/listener.rb

@@ -21,6 +21,10 @@ module Coolio
       @listen_socket.fileno
     end
 
+    def listen(backlog)
+      @listen_socket.listen(backlog)
+    end
+
     # Close the listener
     def close
       detach if attached?
@@ -53,9 +57,9 @@ module Coolio
     end
   end
 
-  class TCPListener < Listener
-    DEFAULT_BACKLOG = 1024
+  DEFAULT_BACKLOG = 1024
 
+  class TCPListener < Listener
     # Create a new Coolio::TCPListener on the specified address and port.
     # Accepts the following options:
     #
@@ -87,7 +91,9 @@ module Coolio
     # Optionally, it can also take anyn existing UNIXServer object
     # and create a Coolio::UNIXListener out of it.
     def initialize(*args)
-      super(::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args))
+      s = ::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args)
+      s.instance_eval { listen(DEFAULT_BACKLOG) }
+      super(s)
     end
   end
 end

data/lib/cool.io/loop.rb

@@ -88,12 +88,12 @@ module Coolio
     # event callbacks to watchers until all watchers associated with
     # the loop have been disabled or detached.  The loop may be
     # explicitly stopped by calling the stop method on the loop object.
-    def run
+    def run(timeout = nil)
       raise RuntimeError, "no watchers for this loop" if @watchers.empty?
 
       @running = true
       while @running and not @active_watchers.zero?
-        run_once
+        run_once(timeout)
       end
       @running = false
     end

data/lib/cool.io/server.rb

@@ -56,7 +56,7 @@ module Coolio
         raise ArgumentError, "port must be an integer" if nil == port
         ::TCPServer.new(host, port)
       end
-      listen_socket.instance_eval { listen(1024) } # Change listen backlog to 1024
+      listen_socket.instance_eval { listen(DEFAULT_BACKLOG) } # Change listen backlog to 1024
       super(listen_socket, klass, *args, &block)
     end
   end
@@ -68,6 +68,7 @@ module Coolio
   class UNIXServer < Server
     def initialize(path, klass = UNIXSocket, *args, &block)
       s = ::UNIXServer === path ? path : ::UNIXServer.new(path)
+      s.instance_eval { listen(DEFAULT_BACKLOG) }
       super(s, klass, *args, &block)
     end
   end

data/lib/cool.io/version.rb

@@ -1,5 +1,5 @@
 module Coolio
-  VERSION = "1.2.0"
+  VERSION = "1.2.3"
   
   def self.version; VERSION; end
 end

data/spec/dns_spec.rb

@@ -36,4 +36,4 @@ describe "DNS" do
       @loop.run
     end.should raise_error(WontResolve)
   end
-end
+end

data/spec/spec_helper.rb

@@ -4,6 +4,13 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'rspec'
 require 'cool.io'
 
+def unused_port
+  s = TCPServer.open(0)
+  port = s.addr[1]
+  s.close
+  port
+end
+
 RSpec.configure do |c|
   if RUBY_PLATFORM =~ /mingw|win32/
     $stderr.puts "Skip some specs on Windows"

data/spec/tcp_server_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+TIMEOUT = 0.010
+HOST = '127.0.0.1'
+PORT = unused_port
+
+def send_data(data)
+  io = TCPSocket.new('127.0.0.1', PORT)
+  begin
+    io.write data
+  ensure
+    io.close
+  end
+end
+
+class MyConnection < Coolio::Socket
+  attr_accessor :data, :connected, :closed
+
+  def initialize(io, on_message)
+    super(io)
+    @on_message = on_message
+  end
+
+  def on_connect
+    @connected = true
+  end
+
+  def on_close
+    @closed = true
+  end
+
+  def on_read(data)
+    @on_message.call(data)
+  end
+end
+
+@data = ""
+def on_message(data)
+  @data = data
+end
+
+def test_run(data = nil)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  thread = Thread.new { reactor.run }
+  send_data(data) if data
+  sleep TIMEOUT
+  reactor.stop
+  server.detach
+  send_data('') # to leave from blocking loop
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+def test_run_once(data = nil)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  thread = Thread.new do
+    reactor.run_once # on_connect
+    reactor.run_once # on_read
+  end
+  send_data(data) if data
+  thread.join
+  server.detach
+  @data
+ensure
+  server.close
+end
+
+def test_run_once_timeout(timeout = TIMEOUT)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  running = true
+  thread = Thread.new { reactor.run_once(timeout) }
+  sleep timeout
+  server.detach
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+def test_run_timeout(data = nil, timeout = TIMEOUT)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  running = true
+  thread = Thread.new do
+    while running and reactor.has_active_watchers?
+      reactor.run_once(timeout)
+    end
+  end
+  send_data(data) if data
+  sleep timeout
+  server.detach
+  running = false # another send is not required
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+# This test should work on Windows
+describe Coolio::TCPServer, :env => :win do
+
+  it '#run' do
+    test_run("hello").should == "hello"
+  end
+
+  it '#run_once' do
+    test_run_once("hello").should == "hello"
+  end
+
+  it '#run_once(timeout)' do
+    test_run_once_timeout # should not block
+  end
+
+  it '#run_once(-timeout)' do
+    expect { test_run_once_timeout(-0.1) }.to raise_error(ArgumentError)
+  end
+
+  it '#run(timeout)' do
+    test_run_timeout("hello").should == "hello"
+  end
+
+end
+

data/spec/unix_server_spec.rb

@@ -11,13 +11,15 @@ describe Cool.io::UNIXServer, :env => :win do
 
   it "creates a new Cool.io::UNIXServer" do
     listener = Cool.io::UNIXListener.new(@tmp.path)
+    listener.listen(24)
     File.socket?(@tmp.path).should == true
   end
 
   it "builds off an existing ::UNIXServer" do
     unix_server = ::UNIXServer.new(@tmp.path)
     File.socket?(@tmp.path).should == true
-    listener = Cool.io::UNIXServer.new(unix_server)
+    listener = Cool.io::UNIXServer.new(unix_server, Coolio::UNIXSocket)
+    listener.listen(24)
     File.socket?(@tmp.path).should == true
     listener.fileno.should == unix_server.fileno
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cool.io
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 25
   prerelease: 
   segments: 
   - 1
   - 2
-  - 0
-  version: 1.2.0
+  - 3
+  version: 1.2.3
 platform: x86-mingw32
 authors: 
 - Tony Arcieri
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-05-27 00:00:00 -07:00
+date: 2014-04-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -130,6 +130,7 @@ files:
 - ext/libev/ev_vars.h
 - ext/libev/ev_win32.c
 - ext/libev/ev_wrap.h
+- ext/libev/ruby_gil.patch
 - ext/libev/test_libev_win32.c
 - lib/.gitignore
 - lib/cool.io.rb
@@ -153,6 +154,7 @@ files:
 - spec/dns_spec.rb
 - spec/spec_helper.rb
 - spec/stat_watcher_spec.rb
+- spec/tcp_server_spec.rb
 - spec/timer_watcher_spec.rb
 - spec/unix_listener_spec.rb
 - spec/unix_server_spec.rb