gb_dispatch 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d9b3773249dedae96894b9cc9addb02ca59c1e2
-  data.tar.gz: c3ee56270eb83c3cf0e68dc0568e450fd718c8c6
+  metadata.gz: b286c03ff9e3e0a61a04f57de98ffa2fe7ac351b
+  data.tar.gz: 12018509b5949974b22228aa45da2f510842e20d
 SHA512:
-  metadata.gz: cf2c44fe50c484e501bd7d89deb51ee47c0349bae1ec9c76f55329600336ea9cddfc5d10456b7ef78a591b7a8e7781465ab9524857ca0c827bf1978ad440a894
-  data.tar.gz: 796181ec676e815b3c57266d58d6224f9fd20d5033c86b7b1b83f7d8c65c55a370f8bb556418ca68de48ea105c4f081be910bda220a6e203d29ed2f43ad507e2
+  metadata.gz: a28e7e5c7fb3e48ebd91b7ee6403eabc298843187b9df271971a9d099a55cc4e21152de0df1a490b30d0466542dab7dd417cdf3c9c728011959ae20688d4d792
+  data.tar.gz: 326a1b1f2c0a14c8f82c6348deea13db1881a58a39bfa1174acda2426a465a245ac49c95bd52d983d8d653a18b1c418bd8c7646193a60d276695925983f0313f

data/.gitignore

@@ -11,4 +11,5 @@
 *.so
 *.o
 *.a
-mkmf.log
+*.gem
+mkmf.log

data/.idea/modules.xml

@@ -2,6 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/gb-dispatch.iml" filepath="$PROJECT_DIR$/.idea/gb-dispatch.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/gb_dispatch.iml" filepath="$PROJECT_DIR$/.idea/gb_dispatch.iml" />
     </modules>
   </component>

data/Gemfile

@@ -3,7 +3,7 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in gb_dispatch.gemspec
 gemspec
 
-gem 'celluloid', '~>0.15.2'
+gem 'celluloid', '<=0.15.2'
 group :test do
   gem 'rspec'
   gem 'simplecov', :require => false

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    gb_dispatch (0.0.1)
-      celluloid (~> 0.15.2)
+    gb_dispatch (0.0.2)
+      celluloid (>= 0.15.2)
 
 GEM
   remote: https://rubygems.org/
@@ -12,7 +12,7 @@ GEM
     diff-lcs (1.2.5)
     docile (1.1.5)
     json (1.8.3)
-    rake (10.3.2)
+    rake (10.5.0)
     rspec (3.4.0)
       rspec-core (~> 3.4.0)
       rspec-expectations (~> 3.4.0)
@@ -26,7 +26,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.4.0)
     rspec-support (3.4.1)
-    simplecov (0.10.0)
+    simplecov (0.11.1)
       docile (~> 1.1.0)
       json (~> 1.8)
       simplecov-html (~> 0.10.0)
@@ -38,8 +38,11 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.6)
-  celluloid (~> 0.15.2)
+  celluloid (<= 0.15.2)
   gb_dispatch!
   rake (~> 10.0)
   rspec
   simplecov
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -1,6 +1,7 @@
-# GbDispatch
+# GBDispatch
 
-Library allows easy to dispatch block of code for queues.
+Library allows to easily dispatch block of code for queues.
+It is inspired by Grand Central Dispatch behaviour.
 
 ## Installation
 
@@ -18,12 +19,18 @@ Or install it yourself as:
 
     $ gem install gb_dispatch
 
+Then in your script
+
+```ruby
+require 'gb_dispatch'
+```
+
 ## Usage
 
 To dispatch asynchronously
 
 ```ruby
-GBDispatch.dispatch_async_on_queue :my_queue do
+GBDispatch.dispatch_async :my_queue do
     puts 'my code here'
 end
 ```
@@ -31,14 +38,51 @@ end
 for synchronous execution
 
 ```ruby
-GBDispatch.dispatch_sync_on_queue :my_queue do
+my_result = GBDispatch.dispatch_sync :my_queue do
+    puts 'my code here'
+end
+```
+
+for delay execution
+
+```ruby
+delay = 4.5 #seconds
+GBDispatch.dispatch_after delay, :my_queue do
     puts 'my code here'
 end
 ```
 
+### Using with Rails
+
+If you are using Rails, all blocks are wrapped in connection pool, 
+so you don't need to worry about creating and removing new connections.
+Only thing you need to do, is to increase connection pool size
+by number of cores of your machine.
+
+## How it works
+
+### Queues
+
+For each created queue there is a new thread created. However this threads
+are used only for scheduling purpose. All code execution happens on execution pool.
+
+Queues ensure order of execution, but they don't guarantee that all blocks from one queue 
+will be executed on the same thread. 
+
+### Execution pool
+
+This is pool of thread where your code will be executed. 
+Amount of threads in the pool match the amount of cores of your machine 
+(except if you have only one core, there will be 2 threads).
+
+### Exceptions
+
+GBDispatch is designed in the way, that if there is exception thrown it will not crash the whole app/script.
+All exceptions will be logged. If you use +#dispatch_sync+ method, thrown exception will be returned as a result of your block.
+
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/gb_dispatch/fork )
+1. Fork it ( https://github.com/GenieBelt/gb_dispatch/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/Rakefile

@@ -11,7 +11,7 @@ task :build => :spec do
   sh 'gem build ./gb_dispatch.gemspec'
 end
 
-task :release do
+task :release_local do
   require './lib/gb_dispatch/version'
   sh "gem push gb_dispatch-#{GBDispatch::VERSION}.gem --host http://tools.bobisdead.com/gems"
 end

data/gb_dispatch.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors = ['Kacper Kawecki']
   spec.email = ['kacper@geniebelt.com']
   spec.summary = %q{GCD emulation for ruby}
-  spec.description = %q{Allows to dispatch block of code for queues}
+  spec.description = %q{Grand central dispatch emulation for ruby. It allows to easily run asynchronous code. }
   spec.homepage = 'https://github.com/GenieBelt/gb-dispatch'
   spec.license = 'MIT'
 
@@ -18,7 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'celluloid', '~> 0.15.2'
+  spec.add_dependency 'celluloid', '>= 0.15.2'
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
 end

data/lib/gb_dispatch/central_dispatch.rb

@@ -16,5 +16,4 @@ class CentralDispatch
       end
     end
   end
-
 end

data/lib/gb_dispatch/manager.rb

@@ -1,12 +1,22 @@
 require 'singleton'
 require 'gb_dispatch/runner'
 require 'gb_dispatch/queue'
+# Queue manager for simulating Grand Central Dispatch behaviour.
+#
+# It is singleton class, so all calls should be invoked through +GBDispatch::Manager.instance+
 module GBDispatch
   class Manager
     include Singleton
 
+    # Returns queue of given name.
+    #
+    # If queue doesn't exists it will create you a new one.
+    # Remember that for each allocated queue, there is new thread allocated.
+    # @param name [String, Symbol] if not passed, default queue will be returned.
+    # @return [GBDispatch::Queue]
     def get_queue(name=:default)
-      queue = Celluloid::Actor[name.to_sym]
+      name = name.to_sym
+      queue = Celluloid::Actor[name]
       unless queue
         supervisor = Queue.supervise_as name, name, @pool
         queue = supervisor.actors.first
@@ -14,19 +24,64 @@ module GBDispatch
       queue
     end
 
-    # @param queue [GBDispatch::Queue]
+    # Run asynchronously given block of code on given queue.
+    #
+    # This is a proxy for {GBDispatch::Queue#perform} method.
+    # @param queue [GBDispatch::Queue] queue on which block will be executed
+    # @return [nil]
+    # @example
+    #   my_queue = GBDispatch::Manager.instance.get_queue :my_queue
+    #   GBDispatch::Manager.instance.run_async_on_queue my_queue do
+    #     #my delayed code here - probably slow one :)
+    #     puts 'Delayed Hello World!'
+    #   end
     def run_async_on_queue(queue)
       queue.async.perform ->() { yield }
     end
 
-    # @param queue [GBDispatch::Queue]
+    # Run given block of code on given queue and wait for result.
+    #
+    # This method use {GBDispatch::Queue#perform} 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
+    #   my_result = GBDispatch::Manager.instance.run_sync_on_queue my_queue do
+    #     # my complicated code here
+    #     puts 'Delayed Hello World!'
+    #     # return value
+    #     42
+    #   end
     def run_sync_on_queue(queue)
       future = queue.future.perform ->() { yield }
       future.value
     end
 
+    # Run given block of code on given queue with delay.
+    # @param time [Fixnum, Float] delay in seconds
+    # @param queue [GBDispatch::Queue] queue on which block will be executed
+    # @return [nil]
+    # @example Will print 'Hello word!' after 5 seconds.
+    #   my_queue = GBDispatch::Manager.instance.get_queue :my_queue
+    #   my_result = GBDispatch::Manager.instance.run_after_on_queue 5, my_queue do
+    #     puts 'Hello World!'
+    #   end
+    #
+    def run_after_on_queue(time, queue)
+      queue.perform_after time, ->(){ yield }
+    end
+
+
+    # :nodoc:
+    def exit
+      @pool.terminate
+      Celluloid::Actor.all.each  do |actor|
+        actor.terminate if actor.alive?
+      end
+    end
+
     private
 
+    # :nodoc:
     def initialize
       @pool = Runner.pool
     end

data/lib/gb_dispatch/queue.rb

@@ -13,9 +13,12 @@ module GBDispatch
       @thread_pool = thread_pool
     end
 
+    # Perform given block
     #
+    # If used with rails it will wrap block with connection pool.
     # @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)
       Thread.current[:name] ||= name
       if defined?(Rails) && defined?(ActiveRecord::Base)
@@ -39,5 +42,16 @@ module GBDispatch
         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.
+    def perform_after(time, block=nil)
+      after(time) do
+        block = ->(){ yield } unless block
+        self.async.perform block
+      end
+    end
   end
 end

data/lib/gb_dispatch/version.rb

@@ -1,3 +1,3 @@
 module GBDispatch
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/lib/gb_dispatch.rb

@@ -1,5 +1,6 @@
 require 'gb_dispatch/version'
 require 'gb_dispatch/manager'
+require 'celluloid'
 
 # Library to dispatch block on queues.
 # It is inspired by GCD but implementation is based on Celluloid.
@@ -12,36 +13,59 @@ require 'gb_dispatch/manager'
 # of the machine.
 #
 module GBDispatch
+  # Get queue of given name
+  # @return [GBDispatch:Queue]
+  # @param name [#to_sym]
+  def self.get_queue(name)
+    GBDispatch::Manager.instance.get_queue(name)
+  end
+
   # Dispatch asynchronously on queue
   # @param queue [Symbol, GBDispatch::Queue] queue object or name
   # @yield block to execute
-  def self.dispatch_async_on_queue(queue)
+  def self.dispatch_async(queue)
     queue = GBDispatch::Manager.instance.get_queue(queue) unless queue.is_a? GBDispatch::Queue
     GBDispatch::Manager.instance.run_async_on_queue queue do
       yield
     end
   end
 
-  # Get queue of given name
-  # @return [GBDispatch:Queue]
-  # @param name [#to_sym]
-  def self.get_queue(name)
-    GBDispatch::Manager.instance.get_queue(name)
+  # Dispatch synchronously on queue and return result
+  # @param queue [Symbol, GBDispatch::Queue] queue object or name
+  # @yield block to execute
+  def self.dispatch_sync(queue)
+    queue = GBDispatch::Manager.instance.get_queue(queue) unless queue.is_a? GBDispatch::Queue
+    GBDispatch::Manager.instance.run_sync_on_queue queue do
+      yield
+    end
   end
 
-  # Dispatch synchronously on queue and return result
+
+  # Dispatch on queue with delay.
+  # @param delay [Fixnum, Float] delay in seconds
   # @param queue [Symbol, GBDispatch::Queue] queue object or name
   # @yield block to execute
-  def self.dispatch_sync_on_queue(queue)
+  def self.dispatch_after(delay, queue)
     queue = GBDispatch::Manager.instance.get_queue(queue) unless queue.is_a? GBDispatch::Queue
     GBDispatch::Manager.instance.run_async_on_queue queue do
       yield
     end
   end
 
+
   # Setup logger. By default it use Celluloid logger
   # @param logger [Logger]
   def self.logger=(logger)
     Celluloid.logger = logger
   end
+
+  class << self
+    alias_method :dispatch_sync_on_queue, :dispatch_sync
+    alias_method :dispatch_async_on_queue, :dispatch_async
+    alias_method :dispatch_after_on_queue, :dispatch_after
+  end
+
+  at_exit do
+    GBDispatch::Manager.instance.exit
+  end
 end

data/spec/dispatch_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'gb_dispatch'
+
+describe GBDispatch do
+
+  it 'should run dispatch_async' do
+    a = []
+    GBDispatch.dispatch_async :test do
+      sleep(0.01)
+      a << 1
+    end
+    GBDispatch.dispatch_async :test do
+      a << 2
+    end
+    expect(a.empty?).to be_truthy
+    sleep(0.02)
+    expect(a).to eq [1, 2]
+  end
+
+  it 'should run dispatch_async_on_queue' do
+    a = []
+    GBDispatch.dispatch_async_on_queue :test do
+      sleep(0.01)
+      a << 1
+    end
+    GBDispatch.dispatch_async_on_queue :test do
+      a << 2
+    end
+    expect(a.empty?).to be_truthy
+    sleep(0.02)
+    expect(a).to eq [1, 2]
+  end
+
+  it 'should run dispatch_sync' do
+    a = []
+    GBDispatch.dispatch_async :test do
+      sleep(0.02)
+      a << 1
+    end
+    result = GBDispatch.dispatch_sync :test do
+      a << 2
+      a
+    end
+    expect(result).to eq [1,2]
+  end
+
+  it 'should run dispatch_sync_on_queue' do
+    a = []
+    GBDispatch.dispatch_async :test do
+      sleep(0.02)
+      a << 1
+    end
+    result = GBDispatch.dispatch_sync_on_queue :test do
+      a << 2
+      a
+    end
+    expect(result).to eq [1,2]
+  end
+
+  it 'should run dispatch_after' do
+    a = []
+    GBDispatch.dispatch_after 0.1, :test do
+      a << 1
+    end
+    expect(a.empty?).to be_truthy
+    sleep(0.15)
+    expect(a).to eq [1]
+  end
+
+  it 'should run dispatch_after_on_queue' do
+    a = []
+    GBDispatch.dispatch_after_on_queue 0.1, :test do
+      a << 1
+    end
+    expect(a.empty?).to be_truthy
+    sleep(0.15)
+    expect(a).to eq [1]
+  end
+
+  it 'should return proper queue' do
+    queue = GBDispatch.get_queue :test
+    expect(queue.name).to eq :test
+    expect(queue).to be_a GBDispatch::Queue
+  end
+end

data/spec/queue_spec.rb

@@ -55,7 +55,7 @@ describe GBDispatch::Queue do
       queue.async.perform ->() do
         (11..20).each { |x| a << x }
       end
-      sleep(0.06)
+      sleep(0.08)
       expect(a).to eq (0..20).to_a
       queue.terminate
     end
@@ -75,6 +75,22 @@ describe GBDispatch::Queue do
     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.perform_after 0.5, ->() { a << rand() }
+      queue.perform_after 0.7, ->() { a << rand() }
+      sleep 0.4
+      expect(a.count).to eq 0
+      sleep 0.2
+      expect(a.count).to eq 1
+      sleep 0.2
+      expect(a.count).to eq 2
+      queue.terminate
+    end
+  end
+
   context 'rails' do
     before(:each) do
       class Rails

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: gb_dispatch
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kacper Kawecki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-12 00:00:00.000000000 Z
+date: 2016-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.15.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.15.2
 - !ruby/object:Gem::Dependency
@@ -52,7 +52,22 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Allows to dispatch block of code for queues
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: 'Grand central dispatch emulation for ruby. It allows to easily run asynchronous
+  code. '
 email:
 - kacper@geniebelt.com
 executables: []
@@ -78,6 +93,7 @@ files:
 - lib/gb_dispatch/queue.rb
 - lib/gb_dispatch/runner.rb
 - lib/gb_dispatch/version.rb
+- spec/dispatch_spec.rb
 - spec/queue_spec.rb
 - spec/runner_spec.rb
 - spec/spec_helper.rb
@@ -101,11 +117,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: GCD emulation for ruby
 test_files:
+- spec/dispatch_spec.rb
 - spec/queue_spec.rb
 - spec/runner_spec.rb
 - spec/spec_helper.rb