Wrote specs for gem configuration.

Author: jdantonio

lib/concurrent/configuration.rb

@@ -1,68 +1,58 @@
+require 'thread'
 require 'concurrent/thread_pool_executor'
 require 'concurrent/processor_count'
 
 module Concurrent
+
+  ConfigurationError = Class.new(StandardError)
+
   class << self
     attr_accessor :configuration
   end
 
   def self.configure
-    yield(configuration)
+    (@mutex ||= Mutex.new).synchronize do
+      yield(configuration)
+    end
   end
 
   class Configuration
     attr_accessor :global_task_pool
     attr_accessor :global_operation_pool
 
     def initialize
-    end
-
-    def cores
       @cores ||= Concurrent::processor_count
     end
 
     def global_task_pool
       @global_task_pool ||= Concurrent::ThreadPoolExecutor.new(
-        min_threads: [2, cores].max,
-        max_threads: [20, cores * 15].max,
-        idletime: 2 * 60,                  # 2 minutes
-        max_queue: 0,                      # unlimited
-        overflow_policy: :abort            # raise an exception
+        min_threads: [2, @cores].max,
+        max_threads: [20, @cores * 15].max,
+        idletime: 2 * 60,                   # 2 minutes
+        max_queue: 0,                       # unlimited
+        overflow_policy: :abort             # raise an exception
       )
     end
 
     def global_operation_pool
-      @global_operation_pool = Concurrent::ThreadPoolExecutor.new(
-        min_threads: [2, cores].max,
-        max_threads: [2, cores].max,
-        idletime: 10 * 60,                 # 10 minutes
-        max_queue: [20, cores * 15].max,
-        overflow_policy: :abort            # raise an exception
+      @global_operation_pool ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: [2, @cores].max,
+        max_threads: [2, @cores].max,
+        idletime: 10 * 60,                  # 10 minutes
+        max_queue: [20, @cores * 15].max,
+        overflow_policy: :abort             # raise an exception
       )
     end
 
     def global_task_pool=(executor)
-      finalize_executor(@global_task_pool)
+      raise ConfigurationError.new('global task pool was already set') unless @global_task_pool.nil?
       @global_task_pool = executor
     end
 
     def global_operation_pool=(executor)
-      finalize_executor(@global_operation_pool)
+      raise ConfigurationError.new('global operation pool was already set') unless @global_operation_pool.nil?
       @global_operation_pool = executor
     end
-
-    private
-
-    def finalize_executor(executor)
-      return if executor.nil?
-      if executor.respond_to?(:shutdown)
-        executor.shutdown
-      elsif executor.respond_to?(:kill)
-        executor.kill
-      end
-    rescue
-      # suppress
-    end
   end
 
   module OptionsParser
@@ -78,22 +68,25 @@ def get_executor_from(opts = {})
     end
   end
 
-  def task(*args, &block)
-    Concurrent.configuration.global_task_pool.post(*args, &block)
-  end
-  module_function :task
+  private
 
-  def operation(*args, &block)
-    Concurrent.configuration.global_operation_pool.post(*args, &block)
+  def self.finalize_executor(executor)
+    return if executor.nil?
+    if executor.respond_to?(:shutdown)
+      executor.shutdown
+    elsif executor.respond_to?(:kill)
+      executor.kill
+    end
+  rescue
+    # suppress
   end
-  module_function :operation
 
   # create the default configuration on load
   self.configuration = Configuration.new
 
   # set exit hook to shutdown global thread pools
   at_exit do
-    self.configuration.global_task_pool = nil
-    self.configuration.global_operation_pool = nil
+    self.finalize_executor(self.configuration.global_task_pool)
+    self.finalize_executor(self.configuration.global_operation_pool)
   end
 end

spec/concurrent/configuration_spec.rb

@@ -2,23 +2,6 @@
 
 module Concurrent
 
-  describe 'module functions' do
-
-    let(:executor){ ImmediateExecutor.new }
-
-    specify '#task posts to the global task pool' do
-      Concurrent.configuration.should_receive(:global_task_pool).and_return(executor)
-      executor.should_receive(:post).with(1, 2, 3)
-      Concurrent::task(1, 2, 3){|a, b, c| nil }
-    end
-
-    specify '#operation posts to the global operation pool' do
-      Concurrent.configuration.should_receive(:global_operation_pool).and_return(executor)
-      executor.should_receive(:post).with(1, 2, 3)
-      Concurrent::operation(1, 2, 3){|a, b, c| nil }
-    end
-  end
-
   describe OptionsParser do
 
     subject do
@@ -92,39 +75,60 @@ module Concurrent
 
   describe Configuration do
 
-    context 'configure' do
-
-      it 'raises an exception if called twice'
-
-      it 'raises an exception if called after tasks post to the thread pool'
-
-      it 'raises an exception if called after operations post to the thread pool'
+    context 'global task pool' do
 
-      it 'allows reconfiguration if set to :test mode'
-    end
+      specify 'reader creates a default pool when first called if none exists' do
+        Concurrent.configuration.global_task_pool.should_not be_nil
+        Concurrent.configuration.global_task_pool.should respond_to(:post)
+      end
 
-    context '#global_task_pool' do
-      pending
-    end
+      specify 'writer memoizes the given executor' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_task_pool = executor
+        end
+        Concurrent.configuration.global_task_pool.should eq executor
+      end
 
-    context '#global_task_pool=' do
-      pending
+      specify 'writer raises an exception if called twice' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_task_pool = executor
+        end
+        expect {
+          Concurrent.configure do |config|
+            config.global_task_pool = executor
+          end
+        }.to raise_error(ConfigurationError)
+      end
     end
 
-    context '#global_operation_pool' do
-      pending
-    end
+    context 'global operation pool' do
 
-    context '#global_operation_pool=' do
-      pending
-    end
+      specify 'reader creates a default pool when first called if none exists' do
+        Concurrent.configuration.global_operation_pool.should_not be_nil
+        Concurrent.configuration.global_operation_pool.should respond_to(:post)
+      end
 
-    context 'cores' do
-      pending
-    end
+      specify 'writer memoizes the given executor' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_operation_pool = executor
+        end
+        Concurrent.configuration.global_operation_pool.should eq executor
+      end
 
-    context '#at_exit shutdown hook' do
-      pending
+      specify 'writer raises an exception if called twice' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_operation_pool = executor
+        end
+        expect {
+          Concurrent.configure do |config|
+            config.global_operation_pool = executor
+          end
+        }.to raise_error(ConfigurationError)
+      end
     end
   end
 end

spec/spec_helper.rb

@@ -27,17 +27,13 @@
   end
 
   config.before(:each) do
+    reset_gem_configuration
   end
 
   config.after(:each) do
     Thread.list.each do |thread|
       thread.kill unless thread == Thread.current
     end
-
-    Concurrent.configure do |config|
-      config.global_task_pool = nil
-      config.global_operation_pool = nil
-    end
   end
 
   config.after(:suite) do

spec/support/functions.rb

@@ -19,3 +19,7 @@ def jruby?
 def rbx?
   RbConfig::CONFIG['ruby_install_name']=~ /^rbx$/i 
 end
+
+def reset_gem_configuration
+  Concurrent.instance_variable_set(:@configuration, Concurrent::Configuration.new)
+end