cool.io 1.2.1 → 1.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8df378d986336f5aa0c79e3c5e31f80a1571ab0d
+  data.tar.gz: 2d9c5aa507a285b4ee129c5a8ccfca8c5f5d8586
+SHA512:
+  metadata.gz: f6a74e7fa7dd6bd728835225ecb8481c2e44a44dad2887aaba7d041d835bdcb76ace90ea2fe4aab6bd5db322f3d9ea0c1e81e4eb68da4a3d75273fdcb6781d86
+  data.tar.gz: deaffe41d393672ffb44c81766460f8e0736a21294e96acabe998fe01ea36dbdd55ef6b1efadf1e675460ffc0be43376052f9a2f4e3344d36e7c8b37730a3bc5

data/.travis.yml

@@ -4,6 +4,8 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.1.1
+  - ruby-head
   - rbx
 
 matrix:

data/CHANGES.md

@@ -1,3 +1,9 @@
+1.2.2
+-----
+
+* Add timeout option to Loop#run and Loop#run_once. Default by nil
+* Support Ruby 2.2.0
+
 1.2.1
 -----
 

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,79 +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;
-}
-
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
-#define HAVE_EV_LOOP_ONESHOT
-
-static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
-{
+  /* libev is patched to release the GIL when it makes its system call */
   RUN_LOOP(loop_data, EVLOOP_ONESHOT);
-}
-#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

@@ -3242,7 +3242,7 @@ time_update (EV_P_ ev_tstamp max_block)
 }
 
 /* ########## COOLIO PATCHERY HO! ########## */
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
 static
 VALUE ev_backend_poll(void **args)
 {
@@ -3257,7 +3257,7 @@ int
 ev_run (EV_P_ int flags)
 {
 /* ########## COOLIO PATCHERY HO! ########## */
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
     void *poll_args[2];
 #endif
 /* ######################################## */
@@ -3415,10 +3415,24 @@ Let this be a lesson to the all: CALLBACKS FUCKING BLOW
 #######################################################################
 */
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+/*
+  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_blocking_region(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
+        rb_thread_call_without_gvl(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
 #else
         backend_poll (EV_A_ waittime);
 #endif

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/version.rb

@@ -1,5 +1,5 @@
 module Coolio
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
   
   def self.version; VERSION; 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,130 @@
+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
+
+describe Coolio::TCPServer 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

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.2.1
-  prerelease: 
+  version: 1.2.2
 platform: ruby
 authors:
 - Tony Arcieri
@@ -10,54 +9,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-21 00:00:00.000000000 Z
+date: 2014-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.13.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.6.0
 description: Cool.io provides a high performance event framework for Ruby which uses
@@ -72,9 +65,9 @@ extensions:
 - ext/iobuffer/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - LICENSE
@@ -148,44 +141,39 @@ 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
 homepage: http://coolio.github.com
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2606014626052723115
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2606014626052723115
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A cool framework for doing high performance I/O in Ruby
 test_files:
 - spec/async_watcher_spec.rb
 - 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