contender 0.1.1 → 0.2.0

data/spec/counter_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Contender
+
+  describe Counter do
+    subject do
+      Counter.new
+    end
+
+    it 'increments the value' do
+      subject.increment
+      subject.increment
+
+      subject.value.should == 2
+    end
+
+    it 'decrements the value' do
+      subject.increment
+      subject.increment
+      subject.decrement
+
+      subject.value.should == 1
+    end
+  end
+
+end

data/spec/direct_executor_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Contender
+
+  describe DirectExecutor do
+    subject do
+      DirectExecutor.new
+    end
+
+    it 'executes blocks in the calling thread' do
+      calling = Thread.current
+
+      block = lambda do
+        calling.should be(Thread.current)
+      end
+
+      subject.execute &block
+    end
+  end
+
+end

data/spec/future_task_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+module Contender
+
+  describe FutureTask do
+    it 'defers the result of executing a task' do
+      result = Object.new
+      block = proc do
+        result
+      end
+
+      task = FutureTask.new block
+      task.call
+
+      task.result.should be(result)
+    end
+
+    it 'defers the failure of executing a task' do
+      block = proc do
+        raise ArgumentError
+      end
+
+      task = FutureTask.new block
+      task.call
+
+      expect {
+        task.result
+      }.to raise_error(ExecutionError)
+    end
+
+    context 'when waiting on the result of the task' do
+      it 'raises an exception if the task is not done before the timeout is reached' do
+        block = Object.new
+        task = FutureTask.new block
+
+        expect {
+          task.result 0
+        }.to raise_error(TimeoutError)
+      end
+
+      it 'raises an exception if the task was cancelled while waiting' do
+        start_latch = CountdownLatch.new 1
+        cancel_latch = CountdownLatch.new 1
+
+        block = Object.new
+        task = FutureTask.new block
+
+        Thread.new do
+          start_latch.countdown
+          begin
+            task.result
+          rescue CancellationError
+            cancel_latch.countdown
+          end
+        end
+
+        start_latch.await
+
+        task.cancel false
+
+        cancel_latch.await
+      end
+
+      it 'returns the result of the task after it has ran' do
+        start_latch = CountdownLatch.new 1
+
+        result = Object.new
+        block = proc do
+          result
+        end
+
+        task = FutureTask.new block
+
+        Thread.new do
+          start_latch.countdown
+          task.call
+        end
+
+        start_latch.await
+        task.result.should be(result)
+      end
+    end
+
+    context 'when cancelling the task' do
+      it 'prevents a task from running if it has not already' do
+        block = Object.new
+
+        task = FutureTask.new block
+        task.cancel false
+
+        expect {
+          task.result
+        }.to raise_error(CancellationError)
+
+        task.cancelled?.should be_true
+      end
+
+      it 'will not cancel a task if it has already finished running' do
+        result = Object.new
+        block = proc do
+          result
+        end
+
+        task = FutureTask.new block
+        task.call
+
+        task.cancel(false).should be_false
+        task.result.should be(result)
+      end
+
+      it 'will not interrupt a task if it is running but should_interrupt is false' do
+        result = Object.new
+
+        start_latch = CountdownLatch.new 1
+        work_latch = CountdownLatch.new 1
+
+        block = proc do
+          start_latch.countdown
+          work_latch.await
+          result
+        end
+
+        task = FutureTask.new block
+
+        thread = Thread.new do
+          task.call
+        end
+
+        start_latch.await
+
+        task.cancel(false).should be_false
+
+        work_latch.countdown
+
+        task.result.should be(result)
+      end
+
+      it 'will interrupt a task if it is running and should_interrupt is true' do
+        start_latch = CountdownLatch.new 1
+        interrupt_latch = CountdownLatch.new 1
+
+        block = proc do
+          start_latch.countdown
+          begin
+            sleep
+          rescue InterruptError
+            interrupt_latch.countdown
+          end
+        end
+
+        task = FutureTask.new block
+
+        Thread.new do
+          task.call
+        end
+
+        start_latch.await
+
+        task.cancel(true).should be_true
+
+        interrupt_latch.await
+
+        expect {
+          task.result
+        }.to raise_error(CancellationError)
+      end
+    end
+  end
+
+end

data/spec/linked_queue_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Contender
+  describe LinkedQueue do
+    it 'works' do
+      q = LinkedQueue.new
+      x = 10_000
+
+      t1 = Thread.new do
+        x.times do
+          q.offer Object.new, 5
+        end
+      end
+
+      t2 = Thread.new do
+        x.times do
+          q.poll 5
+        end
+      end
+
+      t1.join
+      t2.join
+    end
+  end
+end

data/spec/pool/executor_spec.rb

@@ -0,0 +1,436 @@
+require 'spec_helper'
+
+module Contender
+  module Pool
+
+    describe PoolExecutor do
+      include WaitHelper
+
+      context 'task submission' do
+        it 'raises an exception when no task is given' do
+          executor = Contender.single_pool
+          expect {
+            executor.execute
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an exception when the pool is shutdown' do
+          executor = Contender.single_pool
+          executor.shutdown
+
+          expect {
+            executor.execute {}
+          }.to raise_error(TaskRejectionError)
+        end
+
+        it 'raises an exception when the pool state changes while waiting to enqueue a task' do
+          executor = Contender.single_pool
+          executor.prestart
+
+          queue = executor.queue
+
+          task = Object.new
+
+          enqueue_latch = CountdownLatch.new 1
+          start_latch = CountdownLatch.new 1
+          failure_latch = CountdownLatch.new 1
+
+          mock(queue).offer(task) do
+            start_latch.countdown
+            enqueue_latch.await
+
+            true
+          end
+
+          mock(queue).delete(task) do
+            true
+          end
+
+          exception = nil
+          thread = Thread.new do
+            begin
+              executor.execute task
+            rescue
+              exception = $!
+            end
+
+            failure_latch.countdown
+          end
+
+          start_latch.await
+
+          executor.shutdown
+
+          enqueue_latch.countdown
+          failure_latch.await
+
+          exception.should be_a(TaskRejectionError)
+        end
+
+        it 'adds core workers and gives them tasks' do
+          executor = Contender.single_pool
+          queue = executor.queue
+
+          mock.proxy(queue).offer(anything).once
+
+          x = 2
+
+          latch = CountdownLatch.new x
+          x.times do
+            executor.execute do
+              latch.countdown
+            end
+          end
+
+          latch.await
+          executor.shutdown
+        end
+
+        it 'adds a worker when the core worker size is zero' do
+          executor = PoolExecutor.new 0, 1, 60, LinkedQueue.new, SimpleThreadFactory.new
+
+          x = 2
+
+          latch = CountdownLatch.new x
+          x.times do
+            executor.execute do
+              latch.countdown
+            end
+          end
+
+          latch.await
+          executor.shutdown
+        end
+
+        it 'creates additional workers when the queue is full for new tasks' do
+          executor = PoolExecutor.new 1, 2, 60, LinkedQueue.new, SimpleThreadFactory.new
+          executor.prestart
+
+          work_latch = CountdownLatch.new 1
+          task = proc do
+            work_latch.countdown
+          end
+
+          # Simulate the work queue being full
+          queue = executor.queue
+          stub(queue).offer(task) do
+            false
+          end
+
+          executor.execute task
+
+          work_latch.await
+
+          executor.current_size.should == 2
+          executor.shutdown
+        end
+      end
+
+      context 'worker management' do
+        it 'restarts workers when a task raises an exception' do
+          executor = Contender.fixed_pool 1
+
+          latch = CountdownLatch.new 1
+          executor.execute do
+            latch.countdown
+            raise RuntimeError
+          end
+
+          latch.await
+
+          executor.current_size.should == 1
+          executor.shutdown
+        end
+
+        it 'removes extra worker threads if they timeout before work arrives' do
+          executor = Contender.fixed_pool 2, true
+          # The pool scales up to a single thread, but is removed after work is performed
+          executor.work_timeout = 0.1
+
+          latch = CountdownLatch.new 1
+          executor.execute do
+            latch.countdown
+          end
+
+          latch.await
+
+          wait_until do
+            executor.current_size == 0
+          end
+
+          executor.largest_size.should == 1
+        end
+
+        it 'removes core worker threads if core timeout is allowed and they timeout before work arrives' do
+          executor = Contender.single_pool
+          # The pool has a single core worker, but is removed unless work is present
+          executor.work_timeout = 0.1
+          executor.allow_core_timeout = true
+
+          executor.prestart.should be_true
+
+          wait_until do
+            executor.current_size == 0
+          end
+
+          executor.largest_size.should == 1
+        end
+
+        it 'raises an exception if core timeout is enabled but work timeout is <= 0' do
+          executor = Contender.single_pool
+
+          expect {
+            executor.allow_core_timeout = true
+          }.to raise_error(ArgumentError)
+
+          executor.allow_core_timeout = false
+        end
+
+        it 'raises an exception if work timeout is changed to a negative number' do
+          executor = Contender.single_pool
+
+          expect {
+            executor.work_timeout = -1
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an exception if core timeout is enabled and work timeout is changed to <= 0' do
+          executor = Contender.single_pool
+
+          executor.work_timeout = 1
+          executor.allow_core_timeout = true
+
+          expect {
+            executor.work_timeout = 0
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'replaces workers when work timeout is changed' do
+          executor = Contender.fixed_pool 1, true
+          executor.prestart
+
+          executor.work_timeout = 30
+
+          wait_until do
+            executor.current_size == 1
+          end
+
+          executor.shutdown
+        end
+
+        it 'does nothing when work timeout is increased' do
+          executor = Contender.fixed_pool 1, true
+          executor.prestart
+
+          executor.work_timeout = 120
+
+          executor.current_size.should == 1
+
+          executor.shutdown
+        end
+      end
+
+      context 'pool size management' do
+        it 'does not create workers when increasing the core pool size when there is no backlog' do
+          executor = Contender.fixed_pool 2
+
+          executor.core_size.should == 2
+          executor.current_size.should == 0
+
+          executor.core_size = 4
+
+          executor.core_size.should == 4
+          executor.current_size.should == 0
+        end
+
+        it 'increases the maximum size if it is less than the new core size' do
+          executor = Contender.fixed_pool 2
+
+          executor.core_size.should == 2
+          executor.maximum_size.should == 2
+
+          executor.core_size = 4
+
+          executor.core_size.should == 4
+          executor.maximum_size.should == 4
+        end
+
+        it 'interrupts idle workers if the core pool size is decreased' do
+          executor = Contender.fixed_pool 2
+          executor.prestart
+
+          executor.core_size = 1
+
+          wait_until do
+            executor.current_size == 1
+          end
+
+          executor.shutdown
+        end
+
+        it 'creates workers when increaing the core pool size when there is a backlog' do
+          executor = Contender.single_pool
+
+          block_latch = CountdownLatch.new 1
+          executor.execute do
+            block_latch.await
+          end
+
+          work_latch = CountdownLatch.new 1
+          executor.execute do
+            work_latch.countdown
+          end
+
+          executor.core_size = 3
+
+          work_latch.await
+          block_latch.countdown
+
+          executor.current_size.should == 2
+          executor.shutdown
+        end
+
+        it 'raises an exception if core size size is set below 0' do
+          executor = Contender.single_pool
+
+          expect {
+            executor.core_size = -1
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an exception if maximum size is less than 1' do
+          executor = Contender.single_pool
+
+          expect {
+            executor.maximum_size = 0
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'supports prestarting core workers' do
+          executor = Contender.fixed_pool 3
+
+          executor.current_size.should == 0
+
+          executor.prestart.should be_true
+          executor.current_size.should == 1
+
+          executor.prestart!.should == 2
+          executor.current_size.should == 3
+
+          executor.prestart.should be_false
+          executor.prestart!.should == 0
+
+          executor.current_size.should == 3
+
+          executor.shutdown
+        end
+      end
+
+      context 'pool state management' do
+        it 'processes queued tasks after the pool has been shutdown' do
+          executor = Contender.single_pool
+
+          start_latch = CountdownLatch.new 1
+          block_latch = CountdownLatch.new 1
+
+          executor.execute do
+            start_latch.countdown
+            block_latch.await
+          end
+
+          work_latch = CountdownLatch.new 1
+          executor.execute do
+            work_latch.countdown
+          end
+
+          start_latch.await
+
+          executor.shutdown
+
+          executor.backlog.should == 1
+          executor.active_count.should == 1
+
+          block_latch.countdown
+          work_latch.await
+        end
+
+        it 'interrupts tasks when doing a forceful shutdown' do
+          executor = Contender.single_pool
+
+          start_latch = CountdownLatch.new 1
+          interrupt_latch = CountdownLatch.new 1
+
+          executor.execute do
+            start_latch.countdown
+
+            begin
+              sleep
+            rescue Interrupt
+              interrupt_latch.countdown
+            end
+          end
+
+          start_latch.await
+          executor.shutdown!
+
+          interrupt_latch.await
+        end
+
+        it 'supports waiting until the pool is terminated' do
+          executor = Contender.single_pool
+
+          start_latch = CountdownLatch.new 1
+          block_latch = CountdownLatch.new 1
+
+          executor.execute do
+            start_latch.countdown
+            block_latch.await
+          end
+
+          start_latch.await
+          executor.shutdown
+
+          executor.await_termination(0).should be_false
+
+          terminate_latch = CountdownLatch.new 1
+          thread = Thread.new do
+            if executor.await_termination 5
+              terminate_latch.countdown
+            end
+          end
+
+          block_latch.countdown
+          terminate_latch.await
+
+          executor.await_termination(0).should be_true
+        end
+      end
+
+      context 'statistics' do
+        it 'tracks the number of completed tasks' do
+          executor = Contender.fixed_pool 2
+          executor.prestart
+
+          x = 10
+          latch = CountdownLatch.new x
+
+          x.times do
+            executor.execute do
+              latch.countdown
+            end
+          end
+
+          latch.await
+
+          executor.completed_tasks.should == x
+
+          executor.shutdown
+          executor.await_termination 5
+
+          executor.completed_tasks.should == x
+        end
+      end
+    end
+
+  end
+end