gb_dispatch 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd041feeb927183160d8026c38344e6613eb2732
-  data.tar.gz: 64288309c1cace61a076ab1adee82d2a9ef41912
+  metadata.gz: e680d48b7567d1f4aff1ac5fd621da86bd4f333b
+  data.tar.gz: 557546149b930191018e5ccdb9c1096962690a26
 SHA512:
-  metadata.gz: 768ca64392814c1b0a72a9bef66e0114242f4fcb08d5b412e8665aa8bc8e26771d299909bcaf388e8e1717e36a92afb6025f667cd6728010713e117d2ed68554
-  data.tar.gz: 5f412a4ae3d9cdd91f3c3cf50130b206049adf6e426736700ec58ab6cfe0c79b3867008d905bc24fb7e93fb349f1babeafb72af4b3a7ddf074c69fe42dbcf4f5
+  metadata.gz: 99b9194f55c7b6ce44bed5b1989fa4bb327780d83fdd5641fbba6a240be9dee3a5e075708b580dd67512ee85c10e7ce7575f0164094e7403e9c1e184284cac17
+  data.tar.gz: 97549f375b24e1b98d36de93903a8b128d850dce68ffd1c0c7751863130e900074491d7685684911c33071b9b325c855974ce636be5aac5fcccea6e1fde3c5c0

data/Gemfile

@@ -3,6 +3,7 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in gb_dispatch.gemspec
 gemspec
 
+gem 'concurrent-ruby-ext'
 
 group :test do
   gem 'rspec'

data/Gemfile.lock

@@ -1,32 +1,17 @@
 PATH
   remote: .
   specs:
-    gb_dispatch (0.0.4)
-      celluloid (~> 0.17.3)
+    gb_dispatch (0.0.5)
+      concurrent-ruby (~> 1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    celluloid (0.17.3)
-      celluloid-essentials
-      celluloid-extras
-      celluloid-fsm
-      celluloid-pool
-      celluloid-supervision
-      timers (>= 4.1.1)
-    celluloid-essentials (0.20.5)
-      timers (>= 4.1.1)
-    celluloid-extras (0.20.5)
-      timers (>= 4.1.1)
-    celluloid-fsm (0.20.5)
-      timers (>= 4.1.1)
-    celluloid-pool (0.20.5)
-      timers (>= 4.1.1)
-    celluloid-supervision (0.20.5)
-      timers (>= 4.1.1)
+    concurrent-ruby (1.0.0)
+    concurrent-ruby-ext (1.0.0)
+      concurrent-ruby (~> 1.0.0)
     diff-lcs (1.2.5)
     docile (1.1.5)
-    hitimes (1.2.3)
     json (1.8.3)
     rake (10.5.0)
     rspec (3.4.0)
@@ -47,18 +32,14 @@ GEM
       json (~> 1.8)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
-    timers (4.1.1)
-      hitimes
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.6)
+  concurrent-ruby-ext
   gb_dispatch!
   rake (~> 10.0)
   rspec
   simplecov
-
-BUNDLED WITH
-   1.11.2

data/gb_dispatch.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'celluloid', '~> 0.17.3'
+  spec.add_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.4'

data/lib/gb_dispatch/manager.rb

@@ -16,17 +16,17 @@ module GBDispatch
     # @return [GBDispatch::Queue]
     def get_queue(name=:default_queue)
       name = name.to_sym
-      queue = Celluloid::Actor[name]
+      queue = @queues[name]
       unless queue
-        Queue.supervise as: name, args: [name, @pool]
-        queue = Celluloid::Actor[name]
+        @queues[name] = GBDispatch::Queue.new(name)
+        queue = @queues[name]
       end
       queue
     end
 
     # Run asynchronously given block of code on given queue.
     #
-    # This is a proxy for {GBDispatch::Queue#perform} method.
+    # This is a proxy for {GBDispatch::Queue#perform_now} method.
     # @param queue [GBDispatch::Queue] queue on which block will be executed
     # @return [nil]
     # @example
@@ -37,12 +37,12 @@ module GBDispatch
     #   end
     def run_async_on_queue(queue)
       raise ArgumentError.new 'Queue must be GBDispatch::Queue' unless queue.is_a? GBDispatch::Queue
-      queue.async.perform ->() { yield }
+      queue.async.perform_now ->() { yield }
     end
 
     # Run given block of code on given queue and wait for result.
     #
-    # This method use {GBDispatch::Queue#perform} and wait for result.
+    # This method use {GBDispatch::Queue#perform_now} and wait for result.
     # @param queue [GBDispatch::Queue] queue on which block will be executed
     # @example sets +my_result+ to 42
     #   my_queue = GBDispatch::Manager.instance.get_queue :my_queue
@@ -54,7 +54,7 @@ module GBDispatch
     #   end
     def run_sync_on_queue(queue)
       raise ArgumentError.new 'Queue must be GBDispatch::Queue' unless queue.is_a? GBDispatch::Queue
-      future = queue.future.perform ->() { yield }
+      future = queue.await.perform_now ->() { yield }
       future.value
     end
 
@@ -76,17 +76,18 @@ module GBDispatch
 
     # :nodoc:
     def exit
-      @pool.terminate
-      Celluloid::Actor.all.each  do |actor|
-        actor.terminate if actor.alive?
+      @queues.each_key do |name|
+        @queues[name] = nil
       end
+      Runner.pool.shutdown
+      Runner.pool.wait_for_termination
     end
 
     private
 
     # :nodoc:
     def initialize
-      @pool = Runner.pool
+      @queues = Concurrent::Map.new
     end
   end
 end

data/lib/gb_dispatch/queue.rb

@@ -1,17 +1,15 @@
-require 'celluloid/current'
+require 'concurrent'
 module GBDispatch
   class Queue
-    include Celluloid
+    include Concurrent::Async
 
     # @return [String] queue name
     attr_reader :name
 
     # @param name [String] queue name, should be the same as is register in Celluloid
-    # @param thread_pool [Celluloid::Pool] pool of runners for executing code.
-    def initialize(name, thread_pool)
+    def initialize(name)
+      super()
       @name = name
-      @thread_pool = thread_pool
-      @executing = false
     end
 
     # Perform given block
@@ -20,7 +18,7 @@ module GBDispatch
     # @param block [Proc]
     # @yield if there is no block given it yield without param.
     # @return [Object, Exception] returns value of executed block or exception if block execution failed.
-    def perform(block=nil)
+    def perform_now(block=nil)
       Thread.current[:name] ||= name
       if defined?(Rails) && defined?(ActiveRecord::Base)
         thread_block = ->() do
@@ -35,30 +33,25 @@ module GBDispatch
       else
         thread_block = block ? block : ->() { yield }
       end
-      while @executing
-        sleep(0.0001)
+      begin
+        Runner.execute thread_block, name: name
+      rescue Exception => e
+        return e
       end
-      #exclusive do
-        begin
-          @executing = true
-          @thread_pool.execute thread_block, name: name
-        rescue Exception => e
-          return e
-        ensure
-          @executing = false
-        end
-      #end
     end
 
     # Perform block after given period
     # @param time [Fixnum]
     # @param block [Proc]
     # @yield if there is no block given it yield without param.
+    # @return [Concurrent::ScheduledTask]
     def perform_after(time, block=nil)
-      after(time) do
+      task = Concurrent::ScheduledTask.new(time) do
         block = ->(){ yield } unless block
-        self.async.perform block
+        self.async.perform_now block
       end
+      task.execute
+      task
     end
 
     def to_s

data/lib/gb_dispatch/runner.rb

@@ -1,30 +1,55 @@
-require 'celluloid/current'
+require 'concurrent'
 module GBDispatch
   class Runner
-    include Celluloid
+    class << self
+      attr_accessor :pool_size
 
-    # Execute given block.
-    # If there is an exception thrown, it log it and crash actor.
-    # For more information about error handling, check Celluloid documentation.
-    # @param block [Proc]
-    # @param options [Hash]
-    # @option options [Proc] :condition celluloid condition block called on finish with result
-    # @option options [String] :name queue name used for debugging and better logging.
-    def execute(block, options=Hash.new)
-      begin
-        condition = options[:condition]
-        result = block.call
-        condition.call(result) if condition
-        result
-      rescue Exception => e
-        name = options[:name]
-        if defined?(Opbeat)
-          Opbeat.set_context extra: {queue: name} if name
-          Opbeat.capture_exception(e)
+      # Thread pool for async execution.
+      # Pool size is set by default to core numbers or at least 2.
+      # You can increase size of pool by setting :pool_size variable before using pool.
+      # @return [Concurrent::ThreadPoolExecutor]
+      def pool
+        unless @pool
+          self.pool_size ||=2
+          threads = [self.pool_size, 2, Concurrent.processor_count].max
+          @pool = Concurrent::ThreadPoolExecutor.new(
+              min_threads: 2,
+              max_threads: threads,
+              max_queue: 10*threads,
+              fallback_policy: :caller_runs
+          )
         end
-        Celluloid.logger.error "Failed execution of queue #{name} with error #{e.message}"
-        condition.call(e) if condition
-        raise e
+        @pool
+      end
+
+      # Execute given block.
+      # If there is an exception thrown, it log it and crash actor.
+      # For more information about error handling, check Celluloid documentation.
+      # @param block [Proc]
+      # @param options [Hash]
+      # @option options [String] :name queue name used for debugging and better logging.
+      def execute(block, options=Hash.new)
+        future = Concurrent::Future.new(:executor => self.pool) do
+          begin
+            name = options[:name]
+            Thread.current[:name] ||= name if name
+            result = block.call
+            result
+          rescue Exception => e
+            if defined?(Opbeat)
+              Opbeat.set_context extra: {queue: name} if name
+              Opbeat.capture_exception(e)
+            end
+            GBDispatch.logger.error "Failed execution of queue #{name} with error #{e.message}" if GBDispatch.logger
+            raise e
+          end
+        end
+        future.execute
+        future.value
+        if future.rejected?
+          raise future.reason
+        end
+        future.value
       end
     end
   end

data/lib/gb_dispatch/version.rb

@@ -1,3 +1,3 @@
 module GBDispatch
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/spec/dispatch_spec.rb

@@ -26,9 +26,12 @@ describe GBDispatch do
     GBDispatch.dispatch_async_on_queue :test do
       a << 2
     end
+    GBDispatch.dispatch_async_on_queue :test do
+      a << 3
+    end
     expect(a.empty?).to be_truthy
     sleep(0.02)
-    expect(a).to eq [1, 2]
+    expect(a).to eq [1, 2, 3]
   end
 
   it 'should run dispatch_sync' do
@@ -81,5 +84,6 @@ describe GBDispatch do
     queue = GBDispatch.get_queue :test
     expect(queue).to be_a GBDispatch::Queue
     expect(queue.name).to eq :test
+    expect(GBDispatch.get_queue :test).to equal queue
   end
 end

data/spec/queue_spec.rb

@@ -4,81 +4,73 @@ require 'gb_dispatch/runner'
 
 
 describe GBDispatch::Queue do
-  before(:all) { @pool = GBDispatch::Runner.pool }
-  after(:all) { @pool.terminate }
 
   context 'synchronous' do
     it 'should execute lambda' do
       a = :foo
-      queue = GBDispatch::Queue.new(:test, @pool)
-      queue.perform ->() { a = :bar }
+      queue = GBDispatch::Queue.new(:test)
+      queue.await.perform_now ->() { a = :bar }
       expect(a).to eq :bar
-      queue.terminate
     end
 
     it 'should execute block' do
       a = :foo
-      queue = GBDispatch::Queue.new(:test, @pool)
-      queue.perform do
+      queue = GBDispatch::Queue.new(:test)
+      queue.perform_now do
         a = :bar
       end
       expect(a).to eq :bar
-      queue.terminate
     end
 
     it 'should return value of the block' do
-      queue = GBDispatch::Queue.new(:test, @pool)
-      a = queue.perform do
+      queue = GBDispatch::Queue.new(:test)
+      a = queue.perform_now do
         :bar
       end
       expect(a).to eq :bar
-      queue.terminate
     end
 
     it 'should return exception object on failure' do
-      queue = GBDispatch::Queue.new(:test, @pool)
-      a = queue.perform ->() do
+      queue = GBDispatch::Queue.new(:test)
+      a = queue.perform_now ->() do
         raise StandardError.new 'Test error'
       end
       expect(a).to be_kind_of StandardError
-      queue.terminate
     end
   end
 
   context 'asynchronous' do
     it 'should execute in proper order - one after each other' do
       a = []
-      queue = GBDispatch::Queue.new(:test, @pool)
-      queue.async.perform ->() do
+      queue = GBDispatch::Queue.new(:test)
+      queue.async.perform_now ->() do
         (0..10).each { |x| (a << x) && sleep(0.005) }
       end
-      queue.async.perform ->() do
+      queue.async.perform_now ->() do
         (11..20).each { |x| a << x }
       end
       sleep(0.08)
       expect(a).to eq (0..20).to_a
-      queue.terminate
     end
 
     it 'should handle failures nicely' do
-      queue = GBDispatch::Queue.new(:test, @pool)
+      queue = GBDispatch::Queue.new(:test)
       a = :foo
-      queue.async.perform ->() do
+      queue.async.perform_now ->() do
         raise StandardError.new 'Test error'
       end
-      queue.async.perform ->() do
+      queue.async.perform_now ->() do
         a = :bar
       end
       sleep(0.05)
       expect(a).to eq :bar
-      queue.terminate
     end
   end
 
   context 'after' do
     it 'should bea bale to run block of code after specified time' do
       a = []
-      queue = GBDispatch::Queue.new(:test, @pool)
+      queue = GBDispatch::Queue.new(:test)
       queue.perform_after 0.5, ->() { a << rand() }
       queue.perform_after 0.7, ->() { a << rand() }
       sleep 0.4
@@ -87,7 +79,6 @@ describe GBDispatch::Queue do
       expect(a.count).to eq 1
       sleep 0.2
       expect(a.count).to eq 2
-      queue.terminate
     end
   end
 
@@ -138,14 +129,13 @@ describe GBDispatch::Queue do
 
     it 'should wrap execution with connection pool' do
       a = :foo
-      queue = GBDispatch::Queue.new(:test, @pool)
+      queue = GBDispatch::Queue.new(:test)
       expect(ActiveRecord::Base.connection_pool).to receive(:with_connection).and_call_original
       expect(ActiveRecord::Base).to receive(:clear_active_connections!)
-      queue.perform do
+      queue.await.perform_now do
         a = :bar
       end
       expect(a).to eq :bar
-      queue.terminate
     end
   end
 end

data/spec/runner_spec.rb

@@ -5,49 +5,28 @@ describe GBDispatch::Runner do
 
   it 'should execute synchronously' do
     a = :foo
-    actor = GBDispatch::Runner.new
-    actor.execute ->() { a=:bar }
+    GBDispatch::Runner.execute ->() { a=:bar }
     expect(a).to eq :bar
-    actor.terminate
   end
 
   it 'should return result of passed block' do
-    actor = GBDispatch::Runner.new
-    a = actor.execute ->() { :bar }
+    a = GBDispatch::Runner.execute ->() { :bar }
     expect(a).to eq :bar
-    actor.terminate
   end
 
-  it 'should execute async' do
+  it 'should execute on different thread' do
+    Thread.current[:name] = :foo
     a = :foo
-    actor = GBDispatch::Runner.new
-    actor.async.execute ->() do
-      sleep(0.01)
-      a = :bar
-    end
-    expect(a).to eq :foo
-    sleep(0.015)
-    expect(a).to eq :bar
-    actor.terminate
+    GBDispatch::Runner.execute ->() do
+      a = Thread.current[:name]
+    end, name: :bar
+    expect(a).not_to eq :foo
   end
 
-  it 'should support Celluloid Conditions' do
-    a = :foo
-    actor = GBDispatch::Runner.new
-    actor.async.execute ->() { 5+5 }, :condition => ->(result) { a = result }
-    sleep(0.01)
-    expect(a).to eq 10
-    actor.terminate
-  end
 
   context 'error handling' do
     it 'should call Celluloid Conditions with exception' do
-      a = :foo
-      actor = GBDispatch::Runner.new
-      actor.async.execute ->() { raise StandardError.new 'Test' }, :condition => ->(result) { a = result }, name: :fail_test
-      sleep(0.01)
-      expect(a).to be_kind_of StandardError
-      expect(actor.alive?).to be_falsey
+      expect { GBDispatch::Runner.execute ->() { raise StandardError.new 'Test' }, name: :fail_test }.to raise_error StandardError
     end
   end
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: gb_dispatch
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Kacper Kawecki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-16 00:00:00.000000000 Z
+date: 2016-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: celluloid
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.3
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.3
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -132,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: GCD emulation for ruby
@@ -141,3 +141,4 @@ test_files:
 - spec/queue_spec.rb
 - spec/runner_spec.rb
 - spec/spec_helper.rb
+has_rdoc: