cool.io 1.0.0 → 1.9.0

data/lib/coolio.rb

@@ -1,2 +1,2 @@
 # For those people who don't like the cool.io styling...
-require 'cool.io'
+require 'cool.io'

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/libev_win_select.diff

@@ -0,0 +1,130 @@
+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..7050778 100644
+--- a/ext/libev/ev_select.c
++++ b/ext/libev/ev_select.c
+@@ -67,6 +67,54 @@
+ 
+ #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))
++#define EV_WIN_FD_COUNT(set) (((fd_set *)(set))->fd_count)
++/* ######################################## */
++#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 +139,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
+ 
+@@ -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);
+             }
+ 
+           return;
+@@ -230,10 +278,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 +327,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/spec/async_watcher_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path('../spec_helper', __FILE__)
 require 'tempfile'
 require 'fcntl'
 
-describe Cool.io::AsyncWatcher do
+describe Cool.io::AsyncWatcher, :env => :exclude_win do
 
   it "does not signal on spurious wakeups" do
     aw = Cool.io::AsyncWatcher.new
@@ -30,7 +30,7 @@ describe Cool.io::AsyncWatcher do
     end
 
     # ensure children are ready
-    nr_fork.times { rd.sysread(1).should == '.' }
+    nr_fork.times { expect(rd.sysread(1)).to eq('.') }
 
     # send our signals
     nr_signal.times { aw.signal }
@@ -41,15 +41,15 @@ describe Cool.io::AsyncWatcher do
     children.each do |pid|
       Process.kill(:TERM, pid)
       _, status = Process.waitpid2(pid)
-      status.exitstatus.should == 0
+      expect(status.exitstatus).to eq(0)
     end
 
     # we should've written a line for every signal we sent
     lines = tmp.readlines
-    lines.size.should == nr_signal
+    expect(lines.size).to eq(nr_signal)
 
     # theoretically a bad kernel scheduler could give us fewer...
-    lines.sort.uniq.size.should == nr_fork
+    expect(lines.sort.uniq.size).to eq(nr_fork)
 
     tmp.close!
   end

data/spec/dns_spec.rb

@@ -19,21 +19,40 @@ end
 describe "DNS" do
   before :each do
     @loop = Cool.io::Loop.new
+    @preferred_localhost_address = ::Socket.getaddrinfo("localhost", nil).first[3]
   end
   
   it "connects to valid domains" do
-    ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
-    
-    proc do
-      @loop.run
-    end.should raise_error(ItWorked)
+    begin
+      c = ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
+      
+      expect do
+        @loop.run
+      end.to raise_error(ItWorked)
+    ensure
+      c.close
+    end
   end
   
   it "fires on_resolve_failed for invalid domains" do
     ConnectorThingy.connect(INVALID_DOMAIN, 80).attach(@loop)
     
-    proc do
+    expect do
       @loop.run
-    end.should raise_error(WontResolve)
+    end.to raise_error(WontResolve)
+  end
+
+  it "resolve localhost even though hosts is empty" do
+    Tempfile.open("empty") do |file|
+      expect( Coolio::DNSResolver.hosts("localhost", file.path)).to eq @preferred_localhost_address
+    end
   end
-end
+
+  it "resolve missing localhost even though hosts entries exist" do
+    Tempfile.open("empty") do |file|
+      file.puts("127.0.0.1 example.internal")
+      file.flush
+      expect( Coolio::DNSResolver.hosts("localhost", file.path)).to eq @preferred_localhost_address
+    end
+  end
+end

data/spec/iobuffer_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+
+describe Cool.io::Buffer do
+
+  let :buffer do
+    Cool.io::Buffer.new
+  end
+  
+  it "provides a subset of the methods available in Strings" do
+    expect(buffer << "foo").to eq "foo"
+    expect(buffer << "bar").to eq "bar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.size).to eq 6
+  end
+
+  it "provides append and prepend" do
+    expect(buffer.append "bar").to eq "bar"
+    expect(buffer.prepend "foo").to eq "foo"
+    expect(buffer.append "baz").to eq "baz"
+    expect(buffer.to_str).to eq "foobarbaz"
+  end
+  
+  context "#read" do
+    it "can be used to retrieve the contents of a buffer" do
+      expect(buffer << "foo").to eq "foo"
+      expect(buffer.read 2).to eq "fo"
+      expect(buffer << "bar").to eq "bar"
+      expect(buffer.read 2).to eq "ob"
+      expect(buffer << "baz").to eq "baz"
+      expect(buffer.read 3).to eq "arb"
+    end
+  end
+  
+  describe "provides methods for performing non-blocking I/O" do
+    require "tempfile"
+    
+    context "#read_from" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          t = Tempfile.open "read_from"
+          t << "foobar"
+          t.rewind
+          t
+        end
+        
+        it "will read as much data as possible" do
+          expect(buffer.read_from tmp).to eq 6
+          expect(buffer.to_str).to eq "foobar"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          select [], [@sender]
+          @sender.send "foo", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 3
+          expect(buffer.to_str).to eq "foo"
+          
+          select [], [@sender]
+          @sender.send "barbaz", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 6
+          expect(buffer.to_str).to eq "foobarbaz"
+        end
+      end
+    end
+    
+    context "#write_to" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          Tempfile.open "write_to"
+        end
+        it "writes the contents of the buffer" do
+          buffer << "foo"
+          expect(buffer.write_to tmp).to eq 3
+          tmp.rewind
+          expect(tmp.read 3).to eq "foo"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          buffer << "foo"
+          select [], [@sender]
+          expect(buffer.write_to @sender).to eq 3
+          select [@receiver]
+          expect(@receiver.recvfrom_nonblock(3)[0]).to eq "foo"
+        end
+      end
+    end
+  end
+  
+  context "#clear" do
+    it "clear all data" do
+      buffer << "foo"
+      expect(buffer.size).to eq 3
+      expect(buffer.empty?).to eq false
+      buffer.clear
+      expect(buffer.size).to eq 0
+      expect(buffer.empty?).to eq true
+    end
+  end
+  
+  context "#read_frame" do
+    it "Read up to and including the given frame marker" do
+      buffer << "foo\nbarbaz"
+      data = ""
+      expect(buffer.read_frame data, "\n".ord).to eq true
+      expect(buffer.empty?).to eq false
+      expect(data).to eq "foo\n"
+      expect(buffer.to_str).to eq "barbaz"
+      
+      expect(buffer.read_frame data, "\n".ord).to eq false
+      expect(buffer.empty?).to eq true
+      expect(data).to eq "foo\nbarbaz"
+      expect(buffer.to_str).to eq ""
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -2,4 +2,18 @@ $LOAD_PATH.unshift File.dirname(__FILE__)
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
 require 'rspec'
-require 'cool.io'
+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|mswin/
+    $stderr.puts "Skip some specs on Windows"
+    c.filter_run_excluding :env => :exclude_win
+  end
+end

data/spec/stat_watcher_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+TEMP_FILE_PATH = "./test.txt"
+
+INTERVAL = 0.010
+
+class MyStatWatcher < Cool.io::StatWatcher
+  attr_accessor :accessed, :previous, :current
+
+  def initialize(path)
+    super path, INTERVAL
+  end
+
+  def on_change(previous, current)
+    self.accessed = true
+    self.previous = previous
+    self.current  = current
+  end
+end
+
+def run_with_file_change(path)
+  reactor = Cool.io::Loop.new
+
+  sw = MyStatWatcher.new(path)
+  sw.attach(reactor)
+
+  tw = Cool.io::TimerWatcher.new(INTERVAL, true)
+  tw.on_timer do
+    reactor.stop if sw.accessed
+    write_file(path)
+  end
+  tw.attach(reactor)
+
+  reactor.run
+
+  tw.detach
+  sw.detach
+
+  sw
+end
+
+def write_file(path)
+  File.open(path, "w+") { |f| f.write(rand.to_s) }
+end
+
+def delete_file(path)
+  File.delete(TEMP_FILE_PATH)
+end
+
+describe Cool.io::StatWatcher do
+
+  let :watcher do
+    run_with_file_change(TEMP_FILE_PATH)
+  end
+
+  before :each do
+    write_file(TEMP_FILE_PATH)
+  end
+
+  after :each do
+    delete_file(TEMP_FILE_PATH)
+  end
+
+  it "fire on_change when the file it is watching is modified" do
+    expect(watcher.accessed).to eq(true)
+  end
+
+  it "should pass previous and current file stat info given a stat watcher" do
+    expect(watcher.previous.ino).to eq(watcher.current.ino)
+  end
+
+  it "should raise when the handler does not take 2 parameters" do
+    class MyStatWatcher < Cool.io::StatWatcher
+      remove_method :on_change
+      def on_change
+      end
+    end
+    expect { watcher.accessed }.to raise_error(ArgumentError)
+  end
+
+end