concurrent-ruby 0.1.1.pre.3 → 0.1.1.pre.4

data/spec/concurrent/reactor/drb_async_demux_spec.rb

@@ -1,12 +1,12 @@
-require 'spec_helper'
-
-module Concurrent
-  class Reactor
-
-    describe DRbAsyncDemux do
-
-      pending
-
-    end
-  end
-end
+require 'spec_helper'
+
+module Concurrent
+  class Reactor
+
+    describe DRbAsyncDemux do
+
+      pending
+
+    end
+  end
+end

data/spec/concurrent/reactor/tcp_sync_demux_spec.rb

@@ -1,12 +1,12 @@
-require 'spec_helper'
-
-module Concurrent
-  class Reactor
-
-    describe TcpSyncDemux do
-
-      pending
-
-    end
-  end
-end
+require 'spec_helper'
+
+module Concurrent
+  class Reactor
+
+    describe TcpSyncDemux do
+
+      pending
+
+    end
+  end
+end

data/spec/concurrent/reactor_spec.rb

@@ -1,10 +1,351 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Reactor do
-
-    pending
-
-  end
-end
+require 'spec_helper'
+
+module Concurrent
+
+  describe Reactor do
+
+    let(:sync_demux) do
+      Class.new {
+        def initialize
+          @running = false
+          @queue = Queue.new
+        end
+        def start() @running = true; end
+        def stop
+          @queue.push(:stop)
+          @running = false
+        end
+        def stopped?() return ! @running; end
+        def accept()
+          event = @queue.pop
+          if event == :stop
+            return nil
+          else
+            return Reactor::EventContext.new(event)
+          end
+        end
+        def respond(result, message) return [result, message]; end
+        def close() nil; end
+        def send(event) @queue.push(event) end
+      }.new
+    end
+
+    let(:async_demux) do
+      Class.new {
+        def initialize() @running = false; end
+        def start() @running = true; end
+        def stop() @running = false; end
+        def stopped?() return ! @running; end
+        def set_reactor(reactor) @reactor = reactor; end
+        def send(event) @reactor.handle(event); end
+      }.new
+    end
+
+    context '#initialize' do
+
+      it 'raises an exception when the demux is not valid' do
+        lambda {
+          Reactor.new('bogus demux')
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'sets the initial state to not running' do
+        Reactor.new.should_not be_running
+      end
+    end
+
+    context '#running?' do
+
+      it 'returns true when the reactor is running' do
+        reactor = Reactor.new
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        reactor.should be_running
+        reactor.stop
+      end
+
+      it 'returns true when the reactor is stopped' do
+        reactor = Reactor.new
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        reactor.stop
+        sleep(0.1)
+        reactor.should_not be_running
+      end
+    end
+
+    context '#add_handler' do
+
+      it 'raises an exception is the event name is reserved' do
+        reactor = Reactor.new
+        lambda {
+          reactor.add_handler(Reactor::RESERVED_EVENTS.first){ nil }
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'raises an exception if no block is given' do
+        reactor = Reactor.new
+        lambda {
+          reactor.add_handler('no block given')
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'returns true if the handler is added' do
+        reactor = Reactor.new
+        reactor.add_handler('good'){ nil }.should be_true
+      end
+    end
+
+    context '#remove_handler' do
+
+      it 'returns true if the handler is found and removed' do
+        reactor = Reactor.new
+        reactor.add_handler('good'){ nil }
+        reactor.remove_handler('good').should be_true
+      end
+
+      it 'returns false if the handler is not found' do
+        reactor = Reactor.new
+        reactor.remove_handler('not found').should be_false
+      end
+    end
+
+    context '#stop_on_signal' do
+
+      it 'traps each valid signal' do
+        Signal.should_receive(:trap).with('USR1')
+        Signal.should_receive(:trap).with('USR2')
+        reactor = Reactor.new
+        reactor.stop_on_signal('USR1', 'USR2')
+      end
+
+      it 'raises an exception if given an invalid signal' do
+        if mri?
+          reactor = Reactor.new
+          lambda {
+            reactor.stop_on_signal('BOGUS')
+          }.should raise_error(ArgumentError)
+        end
+      end
+
+      it 'stops the reactor when it receives a trapped signal' do
+        reactor = Reactor.new
+        reactor.stop_on_signal('USR1')
+        reactor.should_receive(:stop).with(no_args())
+        Process.kill('USR1', Process.pid)
+        sleep(0.1)
+      end
+    end
+
+    context '#handle' do
+
+      it 'raises an exception if the demux is synchronous' do
+        reactor = Reactor.new(sync_demux)
+        lambda {
+          reactor.handle('event')
+        }.should raise_error(NotImplementedError)
+      end
+
+      it 'returns :stopped if the reactor is not running' do
+        reactor = Reactor.new
+        reactor.handle('event').first.should eq :stopped
+      end
+
+      it 'returns :ok and the block result on success' do
+        reactor = Reactor.new
+        reactor.add_handler(:event){ 10 }
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        result = reactor.handle(:event)
+        result.first.should eq :ok
+        result.last.should eq 10
+        reactor.stop
+      end
+
+      it 'returns :ex and the exception on failure' do
+        reactor = Reactor.new
+        reactor.add_handler(:event){ raise StandardError }
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        result = reactor.handle(:event)
+        result.first.should eq :ex
+        result.last.should be_a(StandardError)
+        reactor.stop
+      end
+
+      it 'returns :noop when there is no handler' do
+        reactor = Reactor.new
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        result = reactor.handle(:event)
+        result.first.should eq :noop
+        reactor.stop
+      end
+
+      it 'triggers handlers added after the reactor is started' do
+        @expected = false
+        reactor = Reactor.new
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        reactor.add_handler(:event){ @expected = true }
+        reactor.handle(:event)
+        @expected.should be_true
+        reactor.stop
+      end
+
+      it 'does not trigger an event that was removed' do
+        @expected = false
+        reactor = Reactor.new
+        reactor.add_handler(:event){ @expected = true }
+        reactor.remove_handler(:event)
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        reactor.handle(:event)
+        @expected.should be_false
+        reactor.stop
+      end
+    end
+
+    context '#start' do
+
+      it 'raises an exception if the reactor is already running' do
+        reactor = Reactor.new
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        lambda {
+          reactor.start
+        }.should raise_error(StandardError)
+        reactor.stop
+      end
+
+      it 'starts the reactor if it is not running' do
+        reactor = Reactor.new(async_demux)
+        reactor.should_receive(:run_async).with(no_args())
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        reactor.should be_running
+        reactor.stop
+
+        reactor = Reactor.new(sync_demux)
+        reactor.should_receive(:run_sync).with(no_args())
+        Thread.new{ reactor.start }
+        sleep(0.1)
+        reactor.should be_running
+        reactor.stop
+      end
+    end
+
+    context '#stop' do
+
+      it 'returns if the reactor is not running' do
+        reactor = Reactor.new
+        reactor.stop.should be_true
+      end
+
+      it 'stops the reactor when running and synchronous' do
+        reactor = Reactor.new(sync_demux)
+        Thread.new{ sleep(0.1); reactor.stop }
+        Thread.pass
+        reactor.start
+      end
+
+      it 'stops the reactor when running and asynchronous' do
+        reactor = Reactor.new(async_demux)
+        Thread.new{ sleep(0.1); reactor.stop }
+        Thread.pass
+        reactor.start
+      end
+
+      it 'stops the reactor when running without a demux' do
+        reactor = Reactor.new
+        Thread.new{ sleep(0.1); reactor.stop }
+        Thread.pass
+        reactor.start
+      end
+    end
+
+    specify 'synchronous demultiplexing' do
+
+      demux = sync_demux
+      reactor = Concurrent::Reactor.new(demux)
+
+      reactor.should_not be_running
+
+      reactor.add_handler(:foo){ 'Foo' }
+      reactor.add_handler(:bar){ 'Bar' }
+      reactor.add_handler(:baz){ 'Baz' }
+      reactor.add_handler(:fubar){ raise StandardError.new('Boom!') }
+
+      reactor.stop_on_signal('USR1')
+
+      demux.should_receive(:respond).with(:ok, 'Foo')
+      demux.send(:foo)
+
+      t = Thread.new do
+        reactor.start
+      end
+      t.abort_on_exception = true
+      sleep(0.1)
+
+      reactor.should be_running
+
+      demux.should_receive(:respond).with(:ok, 'Bar')
+      demux.should_receive(:respond).with(:ok, 'Baz')
+      demux.should_receive(:respond).with(:noop, anything())
+      demux.should_receive(:respond).with(:ex, anything())
+
+      demux.send(:bar)
+      demux.send(:baz)
+      demux.send(:bogus)
+      demux.send(:fubar)
+
+      reactor.should be_running
+
+      Process.kill('USR1', Process.pid)
+      sleep(0.1)
+
+      demux.should_not_receive(:respond).with(:foo, anything())
+      demux.send(:foo)
+      reactor.should_not be_running
+    end
+
+    specify 'asynchronous demultiplexing' do
+
+      demux = async_demux
+      reactor = Concurrent::Reactor.new(demux)
+
+      reactor.should_not be_running
+
+      reactor.add_handler(:foo){ 'Foo' }
+      reactor.add_handler(:bar){ 'Bar' }
+      reactor.add_handler(:baz){ 'Baz' }
+      reactor.add_handler(:fubar){ raise StandardError.new('Boom!') }
+
+      reactor.stop_on_signal('USR2')
+
+      demux.send(:foo).first.should eq :stopped
+
+      t = Thread.new do
+        reactor.start
+      end
+      t.abort_on_exception = true
+      sleep(0.1)
+
+      reactor.should be_running
+
+      demux.send(:foo).should eq [:ok, 'Foo']
+      demux.send(:bar).should eq [:ok, 'Bar']
+      demux.send(:baz).should eq [:ok, 'Baz']
+      demux.send(:bogus).first.should eq :noop
+      demux.send(:fubar).first.should eq :ex
+
+      reactor.should be_running
+
+      Process.kill('USR2', Process.pid)
+      sleep(0.1)
+
+      demux.send(:foo).first.should eq :stopped
+      reactor.should_not be_running
+    end
+  end
+end

data/spec/concurrent/thread_pool_shared.rb

@@ -1,210 +1,209 @@
-require 'spec_helper'
-
-module Concurrent
-
-  share_examples_for 'Thread Pool' do
-
-    context '#running?' do
-
-      it 'returns true when the thread pool is running' do
-        subject.should be_running
-      end
-
-      it 'returns false when the thread pool is shutting down' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.should_not be_running
-      end
-
-      it 'returns false when the thread pool is shutdown' do
-        subject.shutdown
-        subject.should_not be_running
-      end
-
-      it 'returns false when the thread pool is killed' do
-        subject.shutdown
-        subject.should_not be_running
-      end
-    end
-
-    context '#shutdown?' do
-
-      it 'returns true if #shutdown is complete' do
-        subject.shutdown
-        sleep(0.1)
-        subject.should be_shutdown
-      end
-
-      it 'returns false when running' do
-        subject.should_not be_shutdown
-      end
-    end
-
-    context '#killed?' do
-
-      it 'returns true if tasks were killed at shutdown' do
-        subject.post{ sleep(1) }
-        subject.kill
-        subject.should be_killed
-      end
-
-      it 'returns false when running' do
-        subject.should_not be_killed
-      end
-    end
-
-    context '#shutdown' do
-
-      it 'stops accepting new tasks' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        @expected = false
-        subject.post{ @expected = true }.should be_false
-        sleep(1)
-        @expected.should be_false
-      end
-
-      it 'allows in-progress tasks to complete' do
-        @expected = false
-        subject.post{ sleep(0.5); @expected = true }
-        subject.shutdown
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'allows pending tasks to complete' do
-        @expected = false
-        subject.post{ sleep(0.2) }
-        subject.post{ sleep(0.2); @expected = true }
-        subject.shutdown
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'allows threads to exit normally' do
-        pool = FixedThreadPool.new(5)
-        pool.shutdown
-        sleep(1)
-        pool.status.should be_empty
-      end
-    end
-
-    context '#kill' do
-
-      it 'stops accepting new tasks' do
-        subject.post{ sleep(1) }
-        subject.kill
-        @expected = false
-        subject.post{ @expected = true }.should be_false
-        sleep(1)
-        @expected.should be_false
-      end
-
-      it 'attempts to kill all in-progress tasks' do
-        @expected = false
-        subject.post{ sleep(1); @expected = true }
-        subject.kill
-        sleep(1)
-        @expected.should be_false
-      end
-
-      it 'rejects all pending tasks' do
-        @expected = false
-        subject.post{ sleep(0.5) }
-        subject.post{ sleep(0.5); @expected = true }
-        subject.kill
-        sleep(1)
-        @expected.should be_false
-      end
-    end
-
-    context '#wait_for_termination' do
-
-      it 'immediately returns true after shutdown has complete' do
-        subject.shutdown
-        subject.wait_for_termination.should be_true
-      end
-
-      it 'blocks indefinitely when timeout it nil' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.wait_for_termination(nil).should be_true
-      end
-
-      it 'returns true when shutdown sucessfully completes before timeout' do
-        subject.post{ sleep(0.5) }
-        subject.shutdown
-        subject.wait_for_termination(1).should be_true
-      end
-
-      it 'returns false when shutdown fails to complete before timeout' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.wait_for_termination(0.5).should be_false
-      end
-    end
-
-    context '#post' do
-
-      it 'raises an exception if no block is given' do
-        lambda {
-          subject.post
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'returns true when the block is added to the queue' do
-        subject.post{ nil }.should be_true
-      end
-
-      it 'calls the block with the given arguments' do
-        @expected = nil
-        subject.post(1, 2, 3)do |a, b, c|
-          @expected = a + b + c
-        end
-        sleep(0.1)
-        @expected.should eq 6
-      end
-
-      it 'rejects the block while shutting down' do
-        pool = FixedThreadPool.new(5)
-        pool.post{ sleep(1) }
-        pool.shutdown
-        @expected = nil
-        pool.post(1, 2, 3)do |a, b, c|
-          @expected = a + b + c
-        end
-        @expected.should be_nil
-      end
-
-      it 'returns false while shutting down' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.post{ nil }.should be_false
-      end
-
-      it 'rejects the block once shutdown' do
-        pool = FixedThreadPool.new(5)
-        pool.shutdown
-        @expected = nil
-        pool.post(1, 2, 3)do |a, b, c|
-          @expected = a + b + c
-        end
-        @expected.should be_nil
-      end
-
-      it 'returns false once shutdown' do
-        subject.post{ nil }
-        subject.shutdown
-        sleep(0.1)
-        subject.post{ nil }.should be_false
-      end
-
-      it 'aliases #<<' do
-        @expected = false
-        subject << proc { @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+module Concurrent
+
+  share_examples_for 'Thread Pool' do
+
+    context '#running?' do
+
+      it 'returns true when the thread pool is running' do
+        subject.should be_running
+      end
+
+      it 'returns false when the thread pool is shutting down' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.should_not be_running
+      end
+
+      it 'returns false when the thread pool is shutdown' do
+        subject.shutdown
+        subject.should_not be_running
+      end
+
+      it 'returns false when the thread pool is killed' do
+        subject.shutdown
+        subject.should_not be_running
+      end
+    end
+
+    context '#shutdown?' do
+
+      it 'returns true if #shutdown is complete' do
+        subject.shutdown
+        sleep(0.1)
+        subject.should be_shutdown
+      end
+
+      it 'returns false when running' do
+        subject.should_not be_shutdown
+      end
+    end
+
+    context '#killed?' do
+
+      it 'returns true if tasks were killed at shutdown' do
+        subject.post{ sleep(1) }
+        subject.kill
+        subject.should be_killed
+      end
+
+      it 'returns false when running' do
+        subject.should_not be_killed
+      end
+    end
+
+    context '#shutdown' do
+
+      it 'stops accepting new tasks' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        @expected = false
+        subject.post{ @expected = true }.should be_false
+        sleep(1)
+        @expected.should be_false
+      end
+
+      it 'allows in-progress tasks to complete' do
+        @expected = false
+        subject.post{ sleep(0.5); @expected = true }
+        subject.shutdown
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'allows pending tasks to complete' do
+        @expected = false
+        subject.post{ sleep(0.2) }
+        subject.post{ sleep(0.2); @expected = true }
+        subject.shutdown
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'allows threads to exit normally' do
+        subject.shutdown
+        sleep(1)
+        subject.status.should be_empty
+      end
+    end
+
+    context '#kill' do
+
+      it 'stops accepting new tasks' do
+        subject.post{ sleep(1) }
+        subject.kill
+        @expected = false
+        subject.post{ @expected = true }.should be_false
+        sleep(1)
+        @expected.should be_false
+      end
+
+      it 'attempts to kill all in-progress tasks' do
+        @expected = false
+        subject.post{ sleep(1); @expected = true }
+        subject.kill
+        sleep(1)
+        @expected.should be_false
+      end
+
+      it 'rejects all pending tasks' do
+        @expected = false
+        subject.post{ sleep(0.5) }
+        subject.post{ sleep(0.5); @expected = true }
+        subject.kill
+        sleep(1)
+        @expected.should be_false
+      end
+    end
+
+    context '#wait_for_termination' do
+
+      it 'immediately returns true after shutdown has complete' do
+        subject.shutdown
+        subject.wait_for_termination.should be_true
+      end
+
+      it 'blocks indefinitely when timeout it nil' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.wait_for_termination(nil).should be_true
+      end
+
+      it 'returns true when shutdown sucessfully completes before timeout' do
+        subject.post{ sleep(0.5) }
+        subject.shutdown
+        subject.wait_for_termination(1).should be_true
+      end
+
+      it 'returns false when shutdown fails to complete before timeout' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.wait_for_termination(0.5).should be_false
+      end
+    end
+
+    context '#post' do
+
+      it 'raises an exception if no block is given' do
+        lambda {
+          subject.post
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'returns true when the block is added to the queue' do
+        subject.post{ nil }.should be_true
+      end
+
+      it 'calls the block with the given arguments' do
+        @expected = nil
+        subject.post(1, 2, 3)do |a, b, c|
+          @expected = a + b + c
+        end
+        sleep(0.1)
+        @expected.should eq 6
+      end
+
+      it 'rejects the block while shutting down' do
+        pool = FixedThreadPool.new(5)
+        pool.post{ sleep(1) }
+        pool.shutdown
+        @expected = nil
+        pool.post(1, 2, 3)do |a, b, c|
+          @expected = a + b + c
+        end
+        @expected.should be_nil
+      end
+
+      it 'returns false while shutting down' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.post{ nil }.should be_false
+      end
+
+      it 'rejects the block once shutdown' do
+        pool = FixedThreadPool.new(5)
+        pool.shutdown
+        @expected = nil
+        pool.post(1, 2, 3)do |a, b, c|
+          @expected = a + b + c
+        end
+        @expected.should be_nil
+      end
+
+      it 'returns false once shutdown' do
+        subject.post{ nil }
+        subject.shutdown
+        sleep(0.1)
+        subject.post{ nil }.should be_false
+      end
+
+      it 'aliases #<<' do
+        @expected = false
+        subject << proc { @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      end
+    end
+  end
+end