ione 1.2.5 → 1.3.0.pre0

data/spec/ione/io/io_reactor_spec.rb

@@ -7,7 +7,11 @@ module Ione
   module Io
     describe IoReactor do
       let :reactor do
-        described_class.new(selector: selector, clock: clock)
+        described_class.new(options)
+      end
+
+      let :options do
+        {selector: selector, clock: clock, drain_timeout: 3}
       end
 
       let! :selector do
@@ -37,7 +41,7 @@ module Ione
         end
 
         after do
-          reactor.stop if reactor.running?
+          reactor.stop.value if reactor.running?
         end
       end
 
@@ -77,15 +81,16 @@ module Ione
             end
             reactor.start.value
             stopped_future = reactor.stop
-            restarted_future = reactor.start
             sequence = []
             stopped_future.on_complete { sequence << :stopped }
+            restarted_future = reactor.start
             restarted_future.on_complete { sequence << :restarted }
             barrier.push(nil)
             stopped_future.value
             restarted_future.value
+            await { sequence.size >= 2 }
             begin
-              sequence.should eq([:stopped, :restarted])
+              sequence.should == [:stopped, :restarted]
             ensure
               reactor.stop
               barrier.push(nil) while reactor.running?
@@ -93,7 +98,6 @@ module Ione
           end
 
           it 'restarts the reactor even when restarted before a failed stop' do
-            pending 'This test is broken in JRuby' if RUBY_ENGINE == 'jruby'
             barrier = Queue.new
             selector.handler do
               if barrier.pop == :fail
@@ -112,6 +116,7 @@ module Ione
             barrier.push(:fail)
             stopped_future.value rescue nil
             restarted_future.value
+            await { crashed && restarted }
             begin
               crashed.should be_true
               restarted.should be_true
@@ -136,6 +141,8 @@ module Ione
 
         context 'when already started' do
           it 'is not started again' do
+            calls = 0
+            lock = Mutex.new
             ticks = Queue.new
             barrier = Queue.new
             selector.handler do
@@ -176,7 +183,7 @@ module Ione
           reactor.should_not be_running
         end
 
-        it 'keeps running until stop completed' do
+        it 'keeps running until stop completes' do
           running_barrier = Queue.new
           stop_barrier = Queue.new
           selector.handler do
@@ -191,11 +198,125 @@ module Ione
           stop_barrier.push(nil) until future.completed?
         end
 
-        it 'closes all sockets' do
+        it 'unblocks the reactor' do
+          running_barrier = Queue.new
+          selector.handler do |readables, writables, _, _|
+            running_barrier.push(nil)
+            IO.select(readables, writables, nil, 5)
+          end
           reactor.start.value
-          connection = reactor.connect('example.com', 9999, 5).value
-          reactor.stop.value
-          connection.should be_closed
+          running_barrier.pop
+          stopped_future = reactor.stop
+          await { stopped_future.completed? }
+          stopped_future.should be_completed
+          stopped_future.value
+        end
+
+        it 'drains all sockets' do
+          reactor.start.value
+          TCPServer.open(0) do |server|
+            lazy_socket = Thread.start { server.accept }
+            connection = reactor.connect(server.addr[3], server.addr[1], 5).value
+            writable = false
+            connection.stub(:stub_writable?) { writable }
+            class <<connection; alias_method :writable?, :stub_writable?; end
+            connection.write('12345678')
+            release_barrier = barrier = Queue.new
+            selector.handler do |readables, writables, _, _|
+              barrier.pop
+              [[], writables, []]
+            end
+            await { barrier.num_waiting > 0 }
+            barrier = []
+            release_barrier.push(nil)
+            connection.stub(:flush) do
+              writable = false
+            end
+            writable = true
+            reactor.stop.value
+            connection.should have_received(:flush)
+          end
+        end
+
+        it 'waits on drain to complete upto the specified drain timeout' do
+          time = time_increment = next_increment = 0
+          mutex = Mutex.new
+          clock.stub(:now) { mutex.synchronize { time } }
+          selector.handler do |_, writables, _, _|
+            mutex.synchronize do
+              time += time_increment
+              time_increment = next_increment
+            end
+            [[], writables, []]
+          end
+          reactor.start.value
+          TCPServer.open(0) do |server|
+            lazy_socket = Thread.start { server.accept }
+            connection = reactor.connect(server.addr[3], server.addr[1], 5).value
+            stopped_future = nil
+            mutex.synchronize do
+              connection.stub(:writable?).and_return(true)
+              connection.stub(:flush)
+              next_increment = 1
+              stopped_future = reactor.stop
+            end
+            expect { stopped_future.value }.to raise_error(ReactorError, /timeout/)
+            (time).should eq(3)
+          end
+        end
+
+        it 'waits on drain to complete upto five seconds by default' do
+          with_server do |host, port|
+            options.delete(:drain_timeout)
+            time = time_increment = next_increment = 0
+            mutex = Mutex.new
+            clock.stub(:now) { mutex.synchronize { time } }
+            selector.handler do |_, writables, _, _|
+              mutex.synchronize do
+                time += time_increment
+                time_increment = next_increment
+              end
+              [[], writables, []]
+            end
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            stopped_future = nil
+            mutex.synchronize do
+              connection.stub(:writable?).and_return(true)
+              connection.stub(:flush)
+              next_increment = 1
+              stopped_future = reactor.stop
+            end
+            expect { stopped_future.value }.to raise_error(ReactorError, /timeout/)
+            time.should eq(5)
+          end
+        end
+
+        it 'closes all sockets' do
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            reactor.stop.value
+            connection.should be_closed
+          end
+        end
+
+        it 'closes all sockets even if drain fails' do
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            Thread.pass
+            writable = false
+            connection.stub(:stub_writable?) { writable }
+            class <<connection; alias_method :writable?, :stub_writable?; end
+            connection.write('12345678')
+            Thread.pass
+            connection.stub(:flush).and_raise(StandardError, 'Boork')
+            writable = true
+            f = reactor.stop
+            expect { f.value }.to raise_error(StandardError, 'Boork')
+            connection.should be_closed
+          end
         end
 
         it 'cancels all active timers' do
@@ -237,7 +358,7 @@ module Ione
           reactor.on_error { |e| error = e }
           reactor.start
           await { error }
-          error.message.should eq('Blurgh')
+          error.message.should == 'Blurgh'
         end
 
         it 'calls the listener immediately when the reactor has already crashed' do
@@ -266,17 +387,18 @@ module Ione
           reactor.on_error { calls << :post_started }
           barrier.push(nil)
           await { !reactor.running? }
+          await { calls.size >= 2 }
           reactor.on_error { calls << :pre_restarted }
-          calls.should eq([
+          calls.should == [
             :pre_started,
             :post_started,
             :pre_restarted,
-          ])
+          ]
           reactor.start
           reactor.on_error { calls << :post_restarted }
           barrier.push(nil)
           await { !reactor.running? }
-          calls.should eq([
+          calls.should == [
             :pre_started,
             :post_started,
             :pre_restarted,
@@ -284,7 +406,7 @@ module Ione
             :post_started,
             :pre_restarted,
             :post_restarted,
-          ])
+          ]
         end
       end
 
@@ -292,70 +414,90 @@ module Ione
         include_context 'running_reactor'
 
         it 'calls the given block with a connection' do
-          connection = nil
-          reactor.start.value
-          reactor.connect('example.com', 9999, 5) { |c| connection = c }.value
-          connection.should_not be_nil
+          with_server do |host, port|
+            connection = nil
+            reactor.start.value
+            reactor.connect(host, port, 5) { |c| connection = c }.value
+            connection.should_not be_nil
+          end
         end
 
         it 'returns a future that resolves to what the given block returns' do
-          reactor.start.value
-          x = reactor.connect('example.com', 9999, 5) { :foo }.value
-          x.should eq(:foo)
+          with_server do |host, port|
+            reactor.start.value
+            x = reactor.connect(host, port, 5) { :foo }.value
+            x.should == :foo
+          end
         end
 
         it 'defaults to 5 as the connection timeout' do
-          reactor.start.value
-          connection = reactor.connect('example.com', 9999).value
-          connection.connection_timeout.should eq(5)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port).value
+            connection.connection_timeout.should == 5
+          end
         end
 
         it 'takes the connection timeout from the :timeout option' do
-          reactor.start.value
-          connection = reactor.connect('example.com', 9999, timeout: 9).value
-          connection.connection_timeout.should eq(9)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, timeout: 9).value
+            connection.connection_timeout.should == 9
+          end
         end
 
         it 'returns the connection when no block is given' do
-          reactor.start.value
-          reactor.connect('example.com', 9999, 5).value.should be_a(Connection)
+          with_server do |host, port|
+            reactor.start.value
+            reactor.connect(host, port, 5).value.should be_a(Connection)
+          end
         end
 
         it 'creates a connection and passes it to the selector as a readable' do
-          reactor.start.value
-          connection = reactor.connect('example.com', 9999, 5).value
-          await { selector.last_arguments[0].length > 1 }
-          selector.last_arguments[0].should include(connection)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            await { selector.last_arguments[0].length > 1 }
+            selector.last_arguments[0].should include(connection)
+          end
         end
 
         it 'upgrades the connection to SSL' do
-          reactor.start.value
-          connection = reactor.connect('example.com', 9999, ssl: true).value
-          connection.should be_a(SslConnection)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, ssl: true).value
+            connection.should be_a(SslConnection)
+          end
         end
 
         it 'passes an SSL context to the SSL connection' do
-          ssl_context = double(:ssl_context)
-          reactor.start.value
-          f = reactor.connect('example.com', 9999, ssl: ssl_context)
-          expect { f.value }.to raise_error
+          with_server do |host, port|
+            ssl_context = double(:ssl_context)
+            reactor.start.value
+            f = reactor.connect(host, port, ssl: ssl_context)
+            expect { f.value }.to raise_error
+          end
         end
 
         context 'when called before the reactor is started' do
           it 'waits for the reactor to start' do
-            f = reactor.connect('example.com', 9999)
-            reactor.start.value
-            f.value
+            with_server do |host, port|
+              f = reactor.connect(host, port)
+              reactor.start.value
+              f.value
+            end
           end
         end
 
         context 'when called after the reactor has stopped' do
           it 'waits for the reactor to be restarted' do
-            reactor.start.value
-            reactor.stop.value
-            f = reactor.connect('example.com', 9999)
-            reactor.start.value
-            f.value
+            with_server do |host, port|
+              reactor.start.value
+              reactor.stop.value
+              f = reactor.connect(host, port)
+              reactor.start.value
+              f.value
+            end
           end
         end
       end
@@ -377,19 +519,19 @@ module Ione
         it 'returns a future that resolves to what the given block returns' do
           reactor.start.value
           x = reactor.bind(ENV['SERVER_HOST'], port, 5) { |acceptor| :foo }.value
-          x.should eq(:foo)
+          x.should == :foo
         end
 
         it 'defaults to a backlog of 5' do
           reactor.start.value
           acceptor = reactor.bind(ENV['SERVER_HOST'], port).value
-          acceptor.backlog.should eq(5)
+          acceptor.backlog.should == 5
         end
 
         it 'takes the backlog from the :backlog option' do
           reactor.start.value
           acceptor = reactor.bind(ENV['SERVER_HOST'], port, backlog: 9).value
-          acceptor.backlog.should eq(9)
+          acceptor.backlog.should == 9
         end
 
         it 'returns the acceptor when no block is given' do
@@ -442,12 +584,10 @@ module Ione
           end
 
           it 'returns a future that is resolved after the specified duration' do
-            start = Time.now
             clock.stub(:now).and_return(1)
-            f = reactor.schedule_timer(8)
-            clock.stub(:now).and_return(10.1)
+            f = reactor.schedule_timer(0.1)
+            clock.stub(:now).and_return(1.1)
             await { f.resolved? }
-            expect(Time.now - start).to be < 1
           end
         end
 
@@ -760,4 +900,4 @@ module IoReactorSpec
       @body.call(*args)
     end
   end
-end
+end

data/spec/ione/io/ssl_acceptor_spec.rb

@@ -7,7 +7,7 @@ module Ione
   module Io
     describe SslAcceptor do
       let :acceptor do
-        described_class.new('example.com', 4321, 3, unblocker, reactor, ssl_context, socket_impl, ssl_socket_impl)
+        described_class.new('example.com', 4321, backlog = 3, unblocker, reactor, ssl_context, socket_impl, ssl_socket_impl)
       end
 
       let :unblocker do
@@ -80,8 +80,8 @@ module Ione
             acceptor.bind
             acceptor.read
             accepted_handlers.should have(1).item
-            accepted_handlers.first.host.should eq('example.com')
-            accepted_handlers.first.port.should eq(3333)
+            accepted_handlers.first.host.should == 'example.com'
+            accepted_handlers.first.port.should == 3333
           end
 
           it 'returns the raw socket from #to_io' do

data/spec/ione/io/ssl_connection_spec.rb

@@ -124,7 +124,7 @@ module Ione
             end
             handler.connect
             handler.read
-            read_sizes.drop(1).should eq([read_sizes.first] * 3)
+            read_sizes.drop(1).should == [read_sizes.first] * 3
           end
         else
           it 'reads and initial chunk of data' do
@@ -134,7 +134,7 @@ module Ione
             ssl_socket.stub(:read_nonblock).and_return('fooo')
             handler.connect
             handler.read
-            data.should eq(['fooo'])
+            data.should == ['fooo']
           end
 
           it 'reads once, and then again with the value of #pending, until #pending returns zero' do
@@ -149,7 +149,7 @@ module Ione
             end
             handler.connect
             handler.read
-            read_sizes.drop(1).should eq([3, 2, 1])
+            read_sizes.drop(1).should == [3, 2, 1]
           end
         end
 

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require 'bundler/setup'
 
 require 'support/fake_server'
 require 'support/await_helper'
+require 'support/server_helper'
 
 unless ENV['COVERAGE'] == 'no' || RUBY_ENGINE == 'rbx'
   require 'coveralls'
@@ -23,8 +24,4 @@ unless ENV['COVERAGE'] == 'no' || RUBY_ENGINE == 'rbx'
   end
 end
 
-RSpec.configure do |config|
-  config.warnings = true
-end
-
 require 'ione'

data/spec/support/fake_server.rb

@@ -11,7 +11,6 @@ class FakeServer
     @disconnects = 0
     @connections = []
     @received_bytes = ''
-    @running = false
   end
 
   def start(options={})

data/spec/support/server_helper.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module ServerHelper
+  def with_server
+    TCPServer.open(0) do |server|
+      thread = Thread.start { server.accept }
+      yield server.addr[3], server.addr[1]
+      thread.value
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include(ServerHelper)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ione
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.3.0.pre0
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-22 00:00:00.000000000 Z
+date: 2015-11-12 00:00:00.000000000 Z
 dependencies: []
 description: Reactive programming framework for Ruby, painless evented IO, futures
   and an efficient byte buffer
@@ -50,6 +50,7 @@ files:
 - spec/spec_helper.rb
 - spec/support/await_helper.rb
 - spec/support/fake_server.rb
+- spec/support/server_helper.rb
 homepage: http://github.com/iconara/ione
 licenses:
 - Apache License 2.0
@@ -65,28 +66,31 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Reactive programming framework for Ruby
 test_files:
-- spec/spec_helper.rb
-- spec/ione/io/ssl_acceptor_spec.rb
-- spec/ione/io/server_connection_spec.rb
-- spec/ione/io/ssl_server_connection_spec.rb
+- spec/integration/io_spec.rb
+- spec/integration/ssl_spec.rb
+- spec/ione/byte_buffer_spec.rb
+- spec/ione/future_spec.rb
+- spec/ione/heap_spec.rb
 - spec/ione/io/acceptor_spec.rb
+- spec/ione/io/connection_common.rb
 - spec/ione/io/connection_spec.rb
-- spec/ione/io/ssl_connection_spec.rb
 - spec/ione/io/io_reactor_spec.rb
-- spec/ione/io/connection_common.rb
-- spec/ione/heap_spec.rb
-- spec/ione/byte_buffer_spec.rb
-- spec/ione/future_spec.rb
-- spec/integration/ssl_spec.rb
-- spec/integration/io_spec.rb
+- spec/ione/io/server_connection_spec.rb
+- spec/ione/io/ssl_acceptor_spec.rb
+- spec/ione/io/ssl_connection_spec.rb
+- spec/ione/io/ssl_server_connection_spec.rb
+- spec/spec_helper.rb
 - spec/support/await_helper.rb
 - spec/support/fake_server.rb
+- spec/support/server_helper.rb
+has_rdoc: